Release v0.4.1 — browser choice for url-action

Adds optional 'browser' field to url-action; runtime resolves it via
config.BROWSER_PATHS (subprocess.Popen with the chosen exe). When
omitted, falls back to webbrowser.open (system default). Constructor
GUI gains a browser dropdown on URL action and on multi-step URL.
Existing open_browser/youtube/google updated to use yandex by default
since user prefers Yandex Browser.

.gitattributes

@@ -0,0 +1 @@
+*.onnx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -43,7 +43,9 @@ python main.py
   - `MICROPHONE_INDEX = -1` — индекс микрофона (`-1` означает устройство по умолчанию). Если микрофонов несколько и берётся не тот, поменяйте число.
   - `WAKE_WORDS = ('jarvis', 'джарвис')` — варианты транскрипции wake-word, которые принимает Vosk. Если ваш голос/акцент стабильно расшифровывается как, например, `жарвис` — добавьте этот вариант сюда (всё в нижнем регистре).
   - `GROQ_MODEL` — имя модели Groq (по умолчанию `llama-3.3-70b-versatile`).
-- `commands.yaml` — набор голосовых команд и их вариантов для fuzzy-матчинга.
+  - `INTENT_SIMILARITY_THRESHOLD = 0.45` — минимальная косинусная близость для срабатывания команды (см. ниже).
+  - `DENOISE_ENABLED = False` — шумоподавление перед Vosk (см. ниже).
+- `commands.yaml` — набор голосовых команд и их вариантов; матчится семантически по эмбеддингам.
 - `custom-commands/` — скомпилированные AHK-скрипты под конкретный сетап автора оригинала (переключение мониторов, управление Яндекс.Музыкой и т.п.). На вашей машине большая часть из них работать не будет, но ассистент запустится в любом случае.
 
 ## Использование
@@ -63,6 +65,47 @@ python main.py
 - `COMMAND_MIN_LISTEN_MS` — минимальное время записи, чтобы не закрыться мгновенно (1000 мс).
 - `COMMAND_MAX_LISTEN_MS` — жёсткий потолок (15000 мс).
 
+## Семантический матчинг команд
+
+Раньше распознанная фраза сравнивалась с фразами из `commands.yaml` через `fuzzywuzzy.fuzz.ratio` — это срабатывало только на формальное совпадение букв. Теперь используется sentence-transformer `all-MiniLM-L6-v2` (ONNX, CPU) — фраза кодируется в 384-мерный вектор, считается косинусная близость с фразами всех команд, побеждает самая близкая.
+
+Это означает, что фраза `«запусти браузер»` сматчится с командой `open_browser`, даже если в YAML записано только `«открой браузер»` — у них близкий смысл.
+
+- Модель лежит в `models/all-MiniLM-L6-v2/` (87 МБ, хранится через Git LFS — `git lfs pull` после клонирования).
+- Порог `INTENT_SIMILARITY_THRESHOLD = 0.45` (косинус, диапазон [-1; 1], для близких смыслов обычно 0.7+). Ниже порога — «команда не распознана», сработает `not_found.wav` (или ветка `«скажи …»` для LLM).
+- Все фразы из `commands.yaml` эмбеддятся один раз при старте; на каждой команде эмбеддится только распознанная пользователем фраза (~1-5 мс на CPU).
+
+## Шумоподавление перед STT
+
+Опциональный пре-процессинг аудио командного буфера через `noisereduce` (спектральное гейтирование). Помогает в шумных помещениях (кулер, кондиционер, фоновая музыка). К wake-word фазе не применяется — там важна отзывчивость.
+
+В `config.py`:
+
+- `DENOISE_ENABLED = False` — главный тумблер.
+- `DENOISE_PROP = 0.85` — доля подавления (0..1).
+- `DENOISE_STATIONARY = False` — `False` для меняющегося шума (рекомендуется), `True` для стабильного фона.
+
+## Эффекты под AI-ассистента
+
+Silero звучит естественно, но иногда хочется лёгкой «AI-окраски» в духе J.A.R.V.I.S. — узкую полосу, еле заметную реверберацию, при желании небольшой сдвиг высоты. Это тонкий постпроцессинг, голос и sample rate не меняются.
+
+По умолчанию эффекты **выключены**. Включаются в `config.py`:
+
+- `TTS_EFFECTS_ENABLED` — главный тумблер (`False` по умолчанию).
+- `TTS_BANDPASS_LOW_HZ` / `TTS_BANDPASS_HIGH_HZ` — полоса пропускания (по умолчанию 200–7000 Гц). Сужение полосы даёт ощущение «голоса по радио».
+- `TTS_REVERB_WET` (0..1) и `TTS_REVERB_DECAY_MS` — доля мокрого сигнала и длительность хвоста короткой реверберации (по умолчанию 0.20 и 100 мс).
+- `TTS_PITCH_SEMITONES` — сдвиг высоты в полутонах (по умолчанию 0, разумный диапазон ±2).
+
+Фильтры реализованы на `scipy.signal` (IIR, sosfiltfilt — нулевая фазовая задержка), реверберация — несколько затухающих задержанных копий, pitch — ресэмплинг по линейной интерполяции. Всё in-process, без временных файлов и лишних зависимостей.
+
+Быстрое A/B сравнение перед тем как переключать тумблер:
+
+```bash
+.venv\Scripts\python.exe utils\preview_effects.py
+```
+
+Скрипт сгенерирует `sound/_preview_silero_raw.wav` и `sound/_preview_silero_fx.wav` — откройте оба в плеере и решите, нравится ли эффект. Параметры fx-версии берутся из текущего `config.py` (независимо от `TTS_EFFECTS_ENABLED`).
+
 ## Схема commands.yaml
 
 Каждая команда — это пара `phrases` + `action`:

commands.yaml

@@ -2,23 +2,23 @@ open_browser:
   phrases:
     - открой браузер
     - запусти браузер
-    - открой гугл хром
-    - гугл хром
-  action: {type: exe, file: "Run browser.exe"}
+    - открой яндекс
+    - яндекс браузер
+  action: {type: url, href: "about:blank", browser: "yandex"}
 
 open_youtube:
   phrases:
     - открой ютуб
     - ютуб
     - запусти ютуб
-  action: {type: exe, file: "Run youtube.exe"}
+  action: {type: url, href: "https://www.youtube.com", browser: "yandex"}
 
 open_google:
   phrases:
     - открой гугл
     - гугл
     - запусти гугл
-  action: {type: exe, file: "Run google.exe"}
+  action: {type: url, href: "https://www.google.com", browser: "yandex"}
 
 music:
   phrases:

config.py

@@ -6,7 +6,7 @@ load_dotenv("dev.env")
 
 # Конфигурация
 VA_NAME = 'Jarvis'
-VA_VER = "0.3.0"
+VA_VER = "0.4.1"
 VA_ALIAS = ('джарвис',)
 VA_TBR = ('скажи', 'покажи', 'ответь', 'произнеси', 'расскажи', 'сколько', 'слушай')
 
@@ -19,8 +19,12 @@ WAKE_WORDS = ('jarvis', 'джарвис')
 # -1 это стандартное записывающее устройство
 MICROPHONE_INDEX = -1
 
-# Путь к браузеру Google Chrome
-CHROME_PATH = 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe %s'
+BROWSER_PATHS = {
+    'yandex':  'C:/Program Files/Yandex/YandexBrowser/Application/browser.exe',
+    'chrome':  'C:/Program Files/Google/Chrome/Application/chrome.exe',
+    'firefox': 'C:/Program Files/Mozilla Firefox/firefox.exe',
+    'edge':    'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
+}
 
 # Токен Groq
 GROQ_TOKEN = os.getenv('GROQ_TOKEN')
@@ -34,3 +38,23 @@ COMMAND_END_SILENCE_MS = 1200
 COMMAND_MIN_SPEECH_MS = 500
 COMMAND_MIN_LISTEN_MS = 1000
 COMMAND_MAX_LISTEN_MS = 15000
+
+TTS_EFFECTS_ENABLED = False
+TTS_BANDPASS_LOW_HZ = 200
+TTS_BANDPASS_HIGH_HZ = 7000
+TTS_REVERB_WET = 0.20
+TTS_REVERB_DECAY_MS = 100
+TTS_PITCH_SEMITONES = 0
+
+# Семантический матчинг команд через эмбеддинги MiniLM-L6-v2 (ONNX, CPU).
+# Порог — косинусная близость [0..1]. На вход поступает уже отфильтрованная
+# фраза (без алиасов и vа_tbr); 0.45 эмпирически отделяет валидные команды
+# от шума, оставляя запас на разговорные перефразировки.
+INTENT_SIMILARITY_THRESHOLD = 0.45
+
+# Шумоподавление аудио перед Vosk на этапе захвата команды (после wake-word).
+# Спектральное гейтирование через noisereduce; даёт небольшую латентность,
+# поэтому выключено по умолчанию и применяется только к буферу команды.
+DENOISE_ENABLED = False
+DENOISE_PROP = 0.85
+DENOISE_STATIONARY = False

effects.py

@@ -0,0 +1,71 @@
+import numpy as np
+from scipy.signal import butter, sosfiltfilt
+
+
+def _ensure_float32_mono(audio):
+    arr = np.asarray(audio, dtype=np.float32)
+    if arr.ndim > 1:
+        arr = arr.mean(axis=1).astype(np.float32)
+    return arr
+
+
+def apply_bandpass(audio, sr, low_hz=200, high_hz=7000, order=4):
+    arr = _ensure_float32_mono(audio)
+    nyq = 0.5 * sr
+    low = max(low_hz, 1) / nyq
+    high = min(high_hz, int(nyq) - 1) / nyq
+    if not (0 < low < high < 1):
+        return arr
+    sos = butter(order, [low, high], btype='band', output='sos')
+    return sosfiltfilt(sos, arr).astype(np.float32)
+
+
+def apply_reverb(audio, sr, wet=0.20, decay_ms=100, taps=4):
+    arr = _ensure_float32_mono(audio)
+    if wet <= 0 or decay_ms <= 0:
+        return arr
+    dry = max(0.0, 1.0 - wet)
+    out = dry * arr
+    gap = max(1, int(sr * (decay_ms / 1000.0) / taps))
+    gain = wet
+    for i in range(1, taps + 1):
+        delay = gap * i
+        gain *= 0.6
+        if delay >= len(arr):
+            break
+        padded = np.zeros_like(arr)
+        padded[delay:] = arr[:len(arr) - delay]
+        out += gain * padded
+    peak = float(np.max(np.abs(out))) if out.size else 0.0
+    if peak > 0.99:
+        out *= 0.99 / peak
+    return out.astype(np.float32)
+
+
+def apply_pitch(audio, sr, semitones=0):
+    arr = _ensure_float32_mono(audio)
+    if semitones == 0:
+        return arr
+    factor = 2.0 ** (semitones / 12.0)
+    n_out = int(round(len(arr) / factor))
+    if n_out <= 1:
+        return arr
+    src_idx = np.linspace(0, len(arr) - 1, num=n_out).astype(np.float32)
+    lo = np.floor(src_idx).astype(np.int64)
+    hi = np.clip(lo + 1, 0, len(arr) - 1)
+    frac = (src_idx - lo).astype(np.float32)
+    resampled = (1.0 - frac) * arr[lo] + frac * arr[hi]
+    return resampled.astype(np.float32)
+
+
+def process(audio, sr, bandpass=None, reverb=None, pitch_semitones=0):
+    out = _ensure_float32_mono(audio)
+    if bandpass is not None:
+        low, high = bandpass
+        out = apply_bandpass(out, sr, low, high)
+    if reverb is not None:
+        wet, decay_ms = reverb
+        out = apply_reverb(out, sr, wet=wet, decay_ms=decay_ms)
+    if pitch_semitones:
+        out = apply_pitch(out, sr, semitones=pitch_semitones)
+    return out

intent.py

@@ -0,0 +1,79 @@
+import os
+import numpy as np
+import onnxruntime as ort
+from tokenizers import Tokenizer
+
+import config
+
+
+MODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models", "all-MiniLM-L6-v2")
+MAX_TOKENS = 128
+
+
+def _mean_pool(last_hidden: np.ndarray, attention_mask: np.ndarray) -> np.ndarray:
+    mask = attention_mask.astype(np.float32)[..., None]
+    summed = (last_hidden * mask).sum(axis=1)
+    counts = np.clip(mask.sum(axis=1), a_min=1e-9, a_max=None)
+    return summed / counts
+
+
+def _l2_normalize(x: np.ndarray) -> np.ndarray:
+    norm = np.linalg.norm(x, axis=-1, keepdims=True)
+    return x / np.clip(norm, a_min=1e-12, a_max=None)
+
+
+class IntentClassifier:
+    def __init__(self, model_dir: str = MODEL_DIR):
+        tok_path = os.path.join(model_dir, "tokenizer.json")
+        onnx_path = os.path.join(model_dir, "model.onnx")
+        self._tokenizer = Tokenizer.from_file(tok_path)
+        self._tokenizer.enable_truncation(max_length=MAX_TOKENS)
+        self._tokenizer.enable_padding(pad_id=0, pad_token="[PAD]")
+        so = ort.SessionOptions()
+        so.intra_op_num_threads = max(1, (os.cpu_count() or 2) // 2)
+        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        self._session = ort.InferenceSession(onnx_path, sess_options=so, providers=["CPUExecutionProvider"])
+        self._input_names = {inp.name for inp in self._session.get_inputs()}
+        self._cache: dict[str, np.ndarray] = {}
+
+    def embed(self, texts: list[str]) -> np.ndarray:
+        if not texts:
+            return np.zeros((0, 384), dtype=np.float32)
+        encs = self._tokenizer.encode_batch(texts)
+        ids = np.array([e.ids for e in encs], dtype=np.int64)
+        mask = np.array([e.attention_mask for e in encs], dtype=np.int64)
+        feeds = {"input_ids": ids, "attention_mask": mask}
+        if "token_type_ids" in self._input_names:
+            feeds["token_type_ids"] = np.zeros_like(ids)
+        outputs = self._session.run(None, feeds)
+        last_hidden = outputs[0]
+        pooled = _mean_pool(last_hidden, mask)
+        return _l2_normalize(pooled).astype(np.float32)
+
+    def prime(self, candidates: dict[str, list[str]]) -> None:
+        self._cache.clear()
+        for cmd_id, phrases in candidates.items():
+            if not phrases:
+                continue
+            self._cache[cmd_id] = self.embed(list(phrases))
+
+    def match(self, utterance: str, candidates: dict[str, list[str]]) -> dict:
+        utterance = (utterance or "").strip()
+        if not utterance:
+            return {"cmd": "", "score": 0.0}
+        for cmd_id, phrases in candidates.items():
+            if cmd_id not in self._cache and phrases:
+                self._cache[cmd_id] = self.embed(list(phrases))
+        query = self.embed([utterance])[0]
+        best_cmd = ""
+        best_score = -1.0
+        for cmd_id, mat in self._cache.items():
+            sims = mat @ query
+            top = float(sims.max()) if sims.size else -1.0
+            if top > best_score:
+                best_score = top
+                best_cmd = cmd_id
+        threshold = getattr(config, "INTENT_SIMILARITY_THRESHOLD", 0.45)
+        if best_score < threshold:
+            return {"cmd": "", "score": max(0.0, best_score)}
+        return {"cmd": best_cmd, "score": max(0.0, best_score)}

main.py

@@ -10,6 +10,7 @@ import time
 import webbrowser
 from ctypes import POINTER, cast
 
+import numpy as np
 import openai
 from openai import OpenAI
 import simpleaudio as sa
@@ -27,6 +28,7 @@ from rich import print
 
 import config
 import tts
+from intent import IntentClassifier
 
 # some consts
 CDIR = os.getcwd()
@@ -60,6 +62,28 @@ VAD_FRAME_MS = 30
 VAD_FRAME_BYTES = int(samplerate * VAD_FRAME_MS / 1000) * 2
 vad = webrtcvad.Vad(config.VAD_AGGRESSIVENESS)
 
+intent_classifier = IntentClassifier()
+intent_classifier.prime({c: v['phrases'] for c, v in VA_CMD_LIST.items()})
+
+if config.DENOISE_ENABLED:
+    import noisereduce as nr
+else:
+    nr = None
+
+
+def denoise_pcm(raw: bytes) -> bytes:
+    if not raw or nr is None:
+        return raw
+    samples = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
+    reduced = nr.reduce_noise(
+        y=samples,
+        sr=samplerate,
+        prop_decrease=config.DENOISE_PROP,
+        stationary=config.DENOISE_STATIONARY,
+    )
+    clipped = np.clip(reduced * 32768.0, -32768, 32767).astype(np.int16)
+    return clipped.tobytes()
+
 
 def gpt_answer():
     global message_log
@@ -140,9 +164,10 @@ def va_respond(voice: str):
 
     print(cmd)
 
+    min_percent = int(round(config.INTENT_SIMILARITY_THRESHOLD * 100))
     if len(cmd['cmd'].strip()) <= 0:
         return False
-    elif cmd['percent'] < 70 or cmd['cmd'] not in VA_CMD_LIST.keys():
+    elif cmd['percent'] < min_percent or cmd['cmd'] not in VA_CMD_LIST.keys():
         # play("not_found")
         # tts.va_speak("Что?")
         if fuzz.ratio(voice.join(voice.split()[:1]).strip(), "скажи") > 75:
@@ -179,15 +204,9 @@ def filter_cmd(raw_voice: str):
 
 
 def recognize_cmd(cmd: str):
-    rc = {'cmd': '', 'percent': 0}
-    for c, v in VA_CMD_LIST.items():
-        for x in v['phrases']:
-            vrt = fuzz.ratio(cmd, x)
-            if vrt > rc['percent']:
-                rc['cmd'] = c
-                rc['percent'] = vrt
-
-    return rc
+    candidates = {c: v['phrases'] for c, v in VA_CMD_LIST.items()}
+    res = intent_classifier.match(cmd, candidates)
+    return {'cmd': res['cmd'], 'percent': int(round(res['score'] * 100))}
 
 
 def _set_mute(state: int):
@@ -233,6 +252,12 @@ def run_action(action):
         else:
             subprocess.Popen(action['cmd'], shell=True)
     elif t == 'url':
+        browser = action.get('browser')
+        if browser:
+            exe = config.BROWSER_PATHS.get(browser)
+            if exe and os.path.isfile(exe):
+                subprocess.Popen([exe, action['href']])
+                return
         webbrowser.open(action['href'])
     elif t == 'keys':
         import pyautogui
@@ -295,6 +320,7 @@ while True:
         silence_ms = 0
         vad_buf = b""
         finalize = False
+        cmd_buf = b"" if config.DENOISE_ENABLED else None
 
         while True:
             elapsed_ms = (time.time() - listen_started) * 1000
@@ -303,7 +329,10 @@ while True:
 
             pcm = recorder.read()
             sp = struct.pack("h" * len(pcm), *pcm)
+            if cmd_buf is None:
                 kaldi_rec.AcceptWaveform(sp)
+            else:
+                cmd_buf += sp
 
             vad_buf += sp
             while len(vad_buf) >= VAD_FRAME_BYTES:
@@ -322,6 +351,8 @@ while True:
                 break
 
         if finalize or speech_ms > 0:
+            if cmd_buf is not None:
+                kaldi_rec.AcceptWaveform(denoise_pcm(cmd_buf))
             text = json.loads(kaldi_rec.FinalResult()).get("text", "")
             if text:
                 va_respond(text)

models/all-MiniLM-L6-v2/README.md

@@ -0,0 +1,35 @@
+---
+license: apache-2.0
+pipeline_tag: sentence-similarity
+---
+
+ONNX port of [sentence-transformers/all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) for text classification and similarity searches.
+
+### Usage
+
+Here's an example of performing inference using the model with [FastEmbed](https://github.com/qdrant/fastembed).
+
+```py
+from fastembed import TextEmbedding
+
+documents = [
+    "You should stay, study and sprint.",
+    "History can only prepare us to be surprised yet again.",
+]
+
+model = TextEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
+embeddings = list(model.embed(documents))
+
+# [
+#     array([
+#         0.00611658, 0.00068912, -0.0203846, ..., -0.01751488, -0.01174267,
+#         0.01463472
+#     ],
+#           dtype=float32),
+#     array([
+#         0.00173448, -0.00329958, 0.01557874, ..., -0.01473586, 0.0281806,
+#         -0.00448205
+#     ],
+#           dtype=float32)
+# ]
+```

models/all-MiniLM-L6-v2/config.json

@@ -0,0 +1,25 @@
+{
+  "_name_or_path": "sentence-transformers/all-MiniLM-L6-v2",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "transformers_version": "4.36.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

models/all-MiniLM-L6-v2/special_tokens_map.json

@@ -0,0 +1,37 @@
+{
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "[PAD]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

models/all-MiniLM-L6-v2/tokenizer_config.json

@@ -0,0 +1,64 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "max_length": 128,
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_to_multiple_of": null,
+  "pad_token": "[PAD]",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "[SEP]",
+  "stride": 0,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "[UNK]"
+}

requirements.txt

@@ -27,6 +27,13 @@ sounddevice
 PyYAML
 python-dotenv
 
+# Semantic intent classifier (MiniLM-L6-v2 ONNX)
+onnxruntime>=1.17
+tokenizers>=0.15
+
+# Noise suppression before STT (optional, off by default)
+noisereduce>=3.0
+
 # GUI command constructor (tools/command_builder)
 ruamel.yaml
 pywebview

tools/command_builder/schema.py

@@ -65,13 +65,20 @@ class ShellAction:
         return out
 
 
+KNOWN_BROWSERS = ("yandex", "chrome", "firefox", "edge")
+
+
 @dataclass
 class UrlAction:
     href: str
+    browser: Optional[str] = None
     type: str = "url"
 
     def to_dict(self) -> dict:
-        return {"type": "url", "href": self.href}
+        out: dict = {"type": "url", "href": self.href}
+        if self.browser:
+            out["browser"] = self.browser
+        return out
 
 
 @dataclass
@@ -157,7 +164,10 @@ def action_from_dict(data: Any) -> Action:
         href = data.get("href")
         if not href or not isinstance(href, str):
             raise SchemaError("url action requires non-empty 'href' string")
-        return UrlAction(href=href)
+        browser = data.get("browser")
+        if browser is not None and browser not in KNOWN_BROWSERS:
+            raise SchemaError(f"url.browser must be one of {KNOWN_BROWSERS} or omitted")
+        return UrlAction(href=href, browser=browser)
     if t == "keys":
         sequence = data.get("sequence")
         text = data.get("text")

tools/command_builder/web/app.js

@@ -191,10 +191,25 @@
                     <label>URL</label>
                     <input type="text" id="url-href" placeholder="https://example.com">
                 </div>
+                <div class="field">
+                    <label>Браузер</label>
+                    <select id="url-browser">
+                        <option value="">по умолчанию (системный)</option>
+                        <option value="yandex">Yandex Browser</option>
+                        <option value="chrome">Google Chrome</option>
+                        <option value="firefox">Mozilla Firefox</option>
+                        <option value="edge">Microsoft Edge</option>
+                    </select>
+                </div>
             `;
             const inp = f.querySelector("#url-href");
-            if (state.action) inp.value = state.action.href || "";
+            const sel = f.querySelector("#url-browser");
+            if (state.action) {
+                inp.value = state.action.href || "";
+                sel.value = state.action.browser || "";
+            }
             inp.addEventListener("input", () => updateAction());
+            sel.addEventListener("change", () => updateAction());
             return;
         }
 
@@ -481,8 +496,23 @@
                 inp.type = "text";
                 inp.value = step.href || "";
                 inp.placeholder = "https://...";
-                inp.addEventListener("input", () => onChange({ type: "url", href: inp.value }));
+                const sel = document.createElement("select");
+                sel.innerHTML = `
+                    <option value="">по умолчанию (системный)</option>
+                    <option value="yandex">Yandex Browser</option>
+                    <option value="chrome">Google Chrome</option>
+                    <option value="firefox">Mozilla Firefox</option>
+                    <option value="edge">Microsoft Edge</option>`;
+                sel.value = step.browser || "";
+                const apply = () => {
+                    const next = { type: "url", href: inp.value };
+                    if (sel.value) next.browser = sel.value;
+                    onChange(next);
+                };
+                inp.addEventListener("input", apply);
+                sel.addEventListener("change", apply);
                 body.appendChild(wrapField("URL", inp));
+                body.appendChild(wrapField("Браузер", sel));
             } else if (t === "keys") {
                 const inp = document.createElement("input");
                 inp.type = "text";
@@ -569,7 +599,10 @@
             if (delay && delay.value) a.delay_ms = parseInt(delay.value, 10);
             state.action = a;
         } else if (t === "url") {
-            state.action = { type: "url", href: (document.getElementById("url-href")||{}).value || "" };
+            const a = { type: "url", href: (document.getElementById("url-href")||{}).value || "" };
+            const b = (document.getElementById("url-browser")||{}).value;
+            if (b) a.browser = b;
+            state.action = a;
         } else if (t === "keys") {
             const mode = (document.getElementById("keys-mode")||{}).value;
             if (mode === "text") {

tts.py

@@ -1,8 +1,12 @@
 import time
 
+import numpy as np
 import sounddevice as sd
 import torch
 
+import config
+import effects
+
 language = 'ru'
 model_id = 'ru_v3'
 sample_rate = 48000  # 48000
@@ -19,18 +23,39 @@ model, _ = torch.hub.load(repo_or_dir='snakers4/silero-models',
 model.to(device)
 
 
-# воспроизводим
-def va_speak(what: str):
+def _post_process(audio):
+    if not getattr(config, 'TTS_EFFECTS_ENABLED', False):
+        return audio
+
+    arr = np.asarray(audio, dtype=np.float32)
+    low = getattr(config, 'TTS_BANDPASS_LOW_HZ', 0)
+    high = getattr(config, 'TTS_BANDPASS_HIGH_HZ', 0)
+    bandpass = (low, high) if low and high and high > low else None
+
+    wet = float(getattr(config, 'TTS_REVERB_WET', 0.0))
+    decay = int(getattr(config, 'TTS_REVERB_DECAY_MS', 0))
+    reverb = (wet, decay) if wet > 0 and decay > 0 else None
+
+    pitch = int(getattr(config, 'TTS_PITCH_SEMITONES', 0))
+
+    return effects.process(arr, sample_rate,
+                           bandpass=bandpass,
+                           reverb=reverb,
+                           pitch_semitones=pitch)
+
+
+def synthesize(what: str):
     audio = model.apply_tts(text=what + "..",
                             speaker=speaker,
                             sample_rate=sample_rate,
                             put_accent=put_accent,
                             put_yo=put_yo)
+    return _post_process(audio)
+
+
+def va_speak(what: str):
+    audio = synthesize(what)
 
     sd.play(audio, sample_rate * 1.05)
     time.sleep((len(audio) / sample_rate) + 0.5)
     sd.stop()
-
-# sd.play(audio, sample_rate)
-# time.sleep(len(audio) / sample_rate)
-# sd.stop()

utils/preview_effects.py

@@ -0,0 +1,55 @@
+import os
+import sys
+
+import numpy as np
+import soundfile as sf
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import config
+import effects
+import tts
+
+
+PHRASE = "Приветствую, сэр. Все системы в норме."
+OUT_RAW = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                      'sound', '_preview_silero_raw.wav')
+OUT_FX = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                     'sound', '_preview_silero_fx.wav')
+
+
+def _render_raw(text: str) -> np.ndarray:
+    audio = tts.model.apply_tts(text=text + "..",
+                                speaker=tts.speaker,
+                                sample_rate=tts.sample_rate,
+                                put_accent=tts.put_accent,
+                                put_yo=tts.put_yo)
+    return np.asarray(audio, dtype=np.float32)
+
+
+def _render_fx(raw: np.ndarray) -> np.ndarray:
+    return effects.process(
+        raw, tts.sample_rate,
+        bandpass=(config.TTS_BANDPASS_LOW_HZ, config.TTS_BANDPASS_HIGH_HZ),
+        reverb=(config.TTS_REVERB_WET, config.TTS_REVERB_DECAY_MS),
+        pitch_semitones=config.TTS_PITCH_SEMITONES,
+    )
+
+
+def main():
+    print(f"Synthesizing: {PHRASE!r}")
+    raw = _render_raw(PHRASE)
+    fx = _render_fx(raw)
+
+    sf.write(OUT_RAW, raw, tts.sample_rate, subtype='PCM_16')
+    sf.write(OUT_FX, fx, tts.sample_rate, subtype='PCM_16')
+
+    dur_raw = len(raw) / tts.sample_rate
+    dur_fx = len(fx) / tts.sample_rate
+    print(f"raw: {OUT_RAW}  ({len(raw)} samples, {dur_raw:.2f}s)")
+    print(f"fx : {OUT_FX}  ({len(fx)} samples, {dur_fx:.2f}s)")
+    print("Open both in a media player and A/B compare.")
+
+
+if __name__ == '__main__':
+    main()