@lovelace_lol/polymer 0.0.1

package/src/polymer/transcription/state.cljs

@@ -0,0 +1,239 @@
+(ns polymer.transcription.state
+  (:require [clojure.string :as str]
+            [polymer.transcription.domain :as domain]))
+
+;; Transcription state tracks recognition session lifecycle and ordered transcript
+;; facts. Browser APIs such as Web Speech and microphone access are handled by
+;; the agency's effector, outside these pure transitions.
+
+(def default-config
+  {:provider "webSpeech"
+   :lang "en-US"
+   :continuous true
+   :interimResults true
+   :maxAlternatives 1
+   :maxRetries 2
+   :retryDelayMs 100
+   :minConfidence 0
+   :agentFilteringEnabled true
+   :interruptDetectionEnabled true
+   :requireAgentReferenceForInterruption true
+   :interruptionDebugLogging false
+   :interruptionVolumeThreshold 0.035
+   :interruptionReferenceScale 0.45
+   :interruptionReferenceOffset 0.015
+   :interruptionHoldMs 150})
+
+(defn finite-number?
+  [value]
+  (and (number? value) (js/isFinite value)))
+
+(defn number-or
+  [value fallback]
+  (if (finite-number? value) value fallback))
+
+(defn clamp
+  [lo hi value]
+  (min hi (max lo value)))
+
+(defn normalize-config
+  [config]
+  (let [input (merge default-config (domain/data-map config))]
+    {:provider (domain/text-or (:provider input) (:provider default-config))
+     :lang (domain/text-or (:lang input) (:lang default-config))
+     :continuous (boolean (:continuous input))
+     :interimResults (boolean (:interimResults input))
+     :maxAlternatives (int (clamp 1 10 (number-or (:maxAlternatives input)
+                                                  (:maxAlternatives default-config))))
+     :maxRetries (int (clamp 0 10 (number-or (:maxRetries input)
+                                             (:maxRetries default-config))))
+     :retryDelayMs (int (clamp 0 5000 (number-or (:retryDelayMs input)
+                                                 (:retryDelayMs default-config))))
+     :minConfidence (clamp 0 1 (number-or (:minConfidence input)
+                                          (:minConfidence default-config)))
+     :agentFilteringEnabled (boolean (:agentFilteringEnabled input))
+     :interruptDetectionEnabled (boolean (:interruptDetectionEnabled input))
+     :requireAgentReferenceForInterruption (boolean (:requireAgentReferenceForInterruption input))
+     :interruptionDebugLogging (boolean (:interruptionDebugLogging input))
+     :interruptionVolumeThreshold (clamp 0 1 (number-or (:interruptionVolumeThreshold input)
+                                                        (:interruptionVolumeThreshold default-config)))
+     :interruptionReferenceScale (clamp 0 4 (number-or (:interruptionReferenceScale input)
+                                                       (:interruptionReferenceScale default-config)))
+     :interruptionReferenceOffset (clamp 0 1 (number-or (:interruptionReferenceOffset input)
+                                                        (:interruptionReferenceOffset default-config)))
+     :interruptionHoldMs (int (clamp 0 2000 (number-or (:interruptionHoldMs input)
+                                                       (:interruptionHoldMs default-config))))}))
+
+(defn default-state
+  [config]
+  {:agency "transcription"
+   :status "idle"
+   :active false
+   :sessionId nil
+   :sequence 0
+   :currentTranscript nil
+   :isFinal false
+   :lastPartial nil
+   :lastFinal nil
+   :lastError nil
+   :lastTtsEvent nil
+   :agentSpeaking false
+   :agentSpeechStatus "idle"
+   :agentWords #{}
+   :agentScript ""
+   :lastEvent nil
+   :retryCount 0
+   :startedCount 0
+   :stoppedCount 0
+   :partialCount 0
+   :finalCount 0
+   :errorCount 0
+   :ignoredCount 0
+   :interruptionCount 0
+   :config (normalize-config config)})
+
+(defn config->state
+  [config]
+  (default-state config))
+
+(defn visible-state
+  [state]
+  (clj->js state))
+
+(defn configure
+  [state config]
+  (assoc state :config (normalize-config (merge (:config state)
+                                                (domain/data-map config)))))
+
+(defn reset-state
+  [state]
+  (default-state (:config state)))
+
+(defn next-session-id
+  []
+  (str "transcription:" (.now js/Date) ":" (rand-int 1000000)))
+
+(defn start-session
+  [state now-ms]
+  (-> state
+      (assoc :active true
+             :status "starting"
+             :sessionId (next-session-id)
+             :lastError nil
+             :retryCount 0
+             :lastEvent {:type "transcription.status"
+                         :status "starting"
+                         :at now-ms})
+      (update :startedCount inc)))
+
+(defn provider-started
+  [state now-ms]
+  (assoc state
+         :status "listening"
+         :lastError nil
+         :lastEvent {:type "transcription.status"
+                     :status "listening"
+                     :reason "provider-started"
+                     :at now-ms}))
+
+(defn stop-session
+  [state now-ms reason]
+  (-> state
+      (assoc :active false
+             :status "idle"
+             :currentTranscript nil
+             :isFinal false
+             :lastEvent {:type "transcription.status"
+                         :status "idle"
+                         :reason reason
+                         :at now-ms})
+      (update :stoppedCount inc)))
+
+(defn next-sequence
+  [state]
+  (inc (:sequence state)))
+
+(defn record-partial
+  [state fact]
+  (-> state
+      (assoc :status "listening"
+             :sequence (:sequence fact)
+             :currentTranscript (:text fact)
+             :isFinal false
+             :lastPartial fact
+             :lastEvent fact)
+      (update :partialCount inc)))
+
+(defn record-final
+  [state fact]
+  (-> state
+      (assoc :status "listening"
+             :sequence (:sequence fact)
+             :currentTranscript (:text fact)
+             :isFinal true
+             :lastPartial nil
+             :lastFinal fact
+             :lastEvent fact
+             :retryCount 0)
+      (update :finalCount inc)))
+
+(defn record-error
+  [state error now-ms retrying?]
+  (-> state
+      (assoc :status (if retrying? "retrying" "error")
+             :lastError error
+             :lastEvent {:type "transcription.error"
+                         :message error
+                         :retrying retrying?
+                         :at now-ms})
+      (update :errorCount inc)
+      (update :retryCount (fn [count] (if retrying? (inc count) count)))))
+
+(defn record-ignored
+  [state ignored]
+  (-> state
+      (assoc :lastEvent ignored)
+      (update :ignoredCount inc)))
+
+(defn record-interruption
+  [state fact]
+  (-> state
+      (assoc :lastEvent fact)
+      (update :interruptionCount inc)))
+
+(defn record-tts-status
+  [state fact]
+  (let [speaking? (boolean (:speaking fact))
+        phrase (or (:phrase fact) (:text fact))
+        words (or (some-> phrase domain/word-set)
+                  (some->> (:words fact) (map str/lower-case) set))]
+    (cond-> (assoc state
+                   :agentSpeaking speaking?
+                   :agentSpeechStatus (:status fact)
+                   :lastTtsEvent fact
+                   :lastEvent fact)
+      words (assoc :agentWords words
+                   :agentScript (str/lower-case (or phrase
+                                                   (str/join " " (:words fact)))))
+      (not speaking?) (assoc :agentWords #{}
+                             :agentScript ""))))
+
+(defn prepare-agent-speech
+  [state text append?]
+  (let [script (str/lower-case (or text ""))
+        words (domain/word-set script)]
+    (assoc state
+           :agentSpeaking true
+           :agentSpeechStatus "speaking"
+           :agentScript (if append?
+                          (str/trim (str (:agentScript state) " " script))
+                          script)
+           :agentWords (if append?
+                         (into (:agentWords state) words)
+                         words))))
+
+(defn record-agent-word
+  [state word]
+  (let [token (str/lower-case (or word ""))]
+    (cond-> state
+      (seq token) (update :agentWords conj token))))