@staff0rd/assist 0.83.1 → 0.84.0

package/dist/commands/voice/python/voice_daemon.py

@@ -1,7 +1,10 @@
 """Voice daemon entry point — main loop and signal handling."""
 
+import ctypes
+import json
 import os
 import signal
+import subprocess
 import sys
 import time
 
@@ -16,6 +19,73 @@ from wake_word import check_wake_word
 
 import keyboard
 
+
+def _load_voice_config() -> dict:
+    """Load voice config by calling ``assist config get voice``.
+
+    Sets environment variables so other Python modules (audio_capture,
+    vad, smart_turn, stt, wake_word) can read them as before.
+    Returns the parsed config dict.
+    """
+    try:
+        result = subprocess.run(
+            ["assist", "config", "get", "voice"],
+            capture_output=True,
+            text=True,
+            check=True,
+            shell=True,
+        )
+        config = json.loads(result.stdout)
+    except (subprocess.CalledProcessError, json.JSONDecodeError) as exc:
+        log("config_error", str(exc), level="error")
+        return {}
+
+    env_map: dict[str, str | None] = {
+        "VOICE_WAKE_WORDS": ",".join(config.get("wakeWords", [])) or None,
+        "VOICE_MIC": config.get("mic"),
+        "VOICE_MODELS_DIR": os.path.expanduser(v)
+        if (v := config.get("modelsDir"))
+        else None,
+        "VOICE_MODEL_VAD": (config.get("models") or {}).get("vad"),
+        "VOICE_MODEL_SMART_TURN": (config.get("models") or {}).get("smartTurn"),
+    }
+    for key, value in env_map.items():
+        if value:
+            os.environ[key] = value
+
+    log("config_loaded", json.dumps(config))
+    return config
+
+
+def _get_foreground_window_info() -> str:
+    """Return the title and process name of the currently focused window."""
+    user32 = ctypes.windll.user32
+    kernel32 = ctypes.windll.kernel32
+    hwnd = user32.GetForegroundWindow()
+
+    # Window title
+    buf = ctypes.create_unicode_buffer(256)
+    user32.GetWindowTextW(hwnd, buf, 256)
+    title = buf.value
+
+    # Process name from window handle
+    pid = ctypes.c_ulong()
+    user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+    process_name = ""
+    PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+    handle = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid.value)
+    if handle:
+        exe_buf = ctypes.create_unicode_buffer(260)
+        size = ctypes.c_ulong(260)
+        if kernel32.QueryFullProcessImageNameW(handle, 0, exe_buf, ctypes.byref(size)):
+            process_name = exe_buf.value.rsplit("\\", 1)[-1]
+        kernel32.CloseHandle(handle)
+
+    if process_name:
+        return f"{process_name}: {title}"
+    return title
+
+
 # States
 IDLE = "idle"
 LISTENING = "listening"
@@ -36,23 +106,9 @@ STOP_CHUNKS = (STOP_MS * 16000) // (BLOCK_SIZE * 1000)  # ~31 chunks
 ACTIVATED_TIMEOUT = 10.0
 
 
-def _print_vad_bar(
-    prob: float, threshold: float, state: str, chunk: np.ndarray
-) -> None:
-    """Print a live VAD meter to stderr when debug mode is on."""
-    rms = float(np.sqrt(np.mean(chunk**2)))
-    peak = float(np.max(np.abs(chunk)))
-    width = 40
-    filled = int(prob * width)
-    bar = "█" * filled + "░" * (width - filled)
-    marker = ">" if prob > threshold else " "
-    print(
-        f"\r  {marker} VAD {prob:.2f} [{bar}] "
-        f"rms={rms:.4f} peak={peak:.4f} {state:10s}",
-        end="",
-        file=sys.stderr,
-        flush=True,
-    )
+def _print_state(state: str) -> None:
+    """Print the current daemon state to stderr when debug mode is on."""
+    print(f"\r  {state:10s}", end="", file=sys.stderr, flush=True)
 
 
 class VoiceDaemon:
@@ -60,15 +116,17 @@ class VoiceDaemon:
         self._running = True
         self._state = IDLE
         self._audio_buffer: list[np.ndarray] = []
-        self._submit_word = os.environ.get("VOICE_SUBMIT_WORD", "").strip().lower()
+
+        config = _load_voice_config()
+        self._submit_windows: set[str] = set(config.get("submitWindows") or [])
 
         log("daemon_init", "Initializing models...")
         self._mic = AudioCapture()
         self._vad = SileroVAD()
         self._smart_turn = SmartTurn()
         self._stt = ParakeetSTT()
-        if self._submit_word:
-            log("daemon_init", f"Submit word: '{self._submit_word}'")
+        if self._submit_windows:
+            log("daemon_init", f"Submit windows: {self._submit_windows}")
         log("daemon_ready")
 
         # Incremental typing state
@@ -96,7 +154,7 @@ class VoiceDaemon:
 
         if self._state == ACTIVATED:
             # Already activated — everything is the command, no wake word needed
-            partial = self._hide_submit_word(text.strip())
+            partial = text.strip()
             if partial and partial != self._typed_text:
                 if self._typed_text:
                     self._update_typed_text(partial)
@@ -106,41 +164,25 @@ class VoiceDaemon:
         elif not self._wake_detected:
             found, command = check_wake_word(text)
             if found and command:
-                partial = self._hide_submit_word(command)
-                if partial:
-                    self._wake_detected = True
-                    log("wake_word_detected", partial)
-                    if DEBUG:
-                        print(f"  Wake word! Typing: {partial}", file=sys.stderr)
-                    keyboard.type_text(partial)
-                    self._typed_text = partial
+                self._wake_detected = True
+                log("wake_word_detected", command)
+                if DEBUG:
+                    print(f"  Wake word! Typing: {command}", file=sys.stderr)
+                keyboard.type_text(command)
+                self._typed_text = command
         else:
             found, command = check_wake_word(text)
             if found and command:
-                partial = self._hide_submit_word(command)
-                if partial and partial != self._typed_text:
-                    self._update_typed_text(partial)
+                if command != self._typed_text:
+                    self._update_typed_text(command)
 
-    def _strip_submit_word(self, text: str) -> tuple[bool, str]:
-        """Check if text ends with the submit word.
-
-        Returns (should_submit, stripped_text).
-        If no submit word is configured, always returns (True, text).
-        """
-        if not self._submit_word:
-            return True, text
-        words = text.rsplit(None, 1)
-        if len(words) >= 1 and words[-1].lower().rstrip(".,!?") == self._submit_word:
-            stripped = text[: text.lower().rfind(words[-1].lower())].rstrip()
-            return True, stripped
-        return False, text
-
-    def _hide_submit_word(self, text: str) -> str:
-        """Strip trailing submit word from partial text so it's never typed."""
-        if not self._submit_word:
-            return text
-        _, stripped = self._strip_submit_word(text)
-        return stripped
+    def _should_submit(self) -> bool:
+        """Check if the foreground window matches the submit allowlist."""
+        if not self._submit_windows:
+            return True
+        info = _get_foreground_window_info()
+        process_name = info.split(":")[0].strip() if ":" in info else ""
+        return process_name in self._submit_windows
 
     def _update_typed_text(self, new_text: str) -> None:
         """Diff old typed text vs new, backspace + type the difference."""
@@ -212,26 +254,18 @@ class VoiceDaemon:
                 log("smart_turn_incomplete", "Continuing to listen...")
         return False
 
-    def _dispatch_result(self, should_submit: bool, stripped: str) -> None:
+    def _dispatch_result(self, text: str) -> None:
         """Log and optionally submit a recognized command."""
-        if stripped:
-            if should_submit:
-                log("dispatch_enter", stripped)
-                if DEBUG:
-                    print(f"  Final: {stripped} [Enter]", file=sys.stderr)
-                keyboard.press_enter()
-            else:
-                log("dispatch_typed", stripped)
-                if DEBUG:
-                    print(f"  Final: {stripped} (no submit)", file=sys.stderr)
-        elif should_submit:
-            # Submit word only — erase it and press enter
-            if self._typed_text:
-                keyboard.backspace(len(self._typed_text))
-            log("dispatch_enter", "(submit word only)")
+        should_submit = self._should_submit()
+        if should_submit:
+            log("dispatch_enter", text)
             if DEBUG:
-                print("  Submit word only [Enter]", file=sys.stderr)
+                print(f"  Final: {text} [Enter]", file=sys.stderr)
             keyboard.press_enter()
+        else:
+            log("dispatch_typed", text)
+            if DEBUG:
+                print(f"  Final: {text} (no submit)", file=sys.stderr)
 
     def _finalize_utterance(self) -> None:
         """End of turn: final STT, correct typed text, press Enter."""
@@ -252,14 +286,12 @@ class VoiceDaemon:
             # Activated mode — full text is the command
             command = text.strip()
             if command:
-                should_submit, stripped = self._strip_submit_word(command)
-                if stripped:
-                    if stripped != self._typed_text:
-                        if self._typed_text:
-                            self._update_typed_text(stripped)
-                        else:
-                            keyboard.type_text(stripped)
-                self._dispatch_result(should_submit, stripped)
+                if command != self._typed_text:
+                    if self._typed_text:
+                        self._update_typed_text(command)
+                    else:
+                        keyboard.type_text(command)
+                self._dispatch_result(command)
             else:
                 if self._typed_text:
                     keyboard.backspace(len(self._typed_text))
@@ -271,11 +303,9 @@ class VoiceDaemon:
             # Correct final text and submit
             found, command = check_wake_word(text)
             if found and command:
-                should_submit, stripped = self._strip_submit_word(command)
-                if stripped:
-                    if stripped != self._typed_text:
-                        self._update_typed_text(stripped)
-                self._dispatch_result(should_submit, stripped)
+                if command != self._typed_text:
+                    self._update_typed_text(command)
+                self._dispatch_result(command)
             elif found:
                 # Wake word found but no command text after it
                 if self._typed_text:
@@ -285,29 +315,16 @@ class VoiceDaemon:
                 # Final transcription lost the wake word (e.g. audio clipping
                 # turned "computer" into "uter"); fall back to the command
                 # captured during streaming
-                should_submit, stripped = self._strip_submit_word(self._typed_text)
-                self._dispatch_result(should_submit, stripped or self._typed_text)
+                self._dispatch_result(self._typed_text)
         else:
             # Check final transcription for wake word
             found, command = check_wake_word(text)
             if found and command:
-                should_submit, stripped = self._strip_submit_word(command)
-                if stripped:
-                    log("wake_word_detected", stripped)
-                    if DEBUG:
-                        label = "[Enter]" if should_submit else "(no submit)"
-                        print(
-                            f"  Wake word! Final: {stripped} {label}", file=sys.stderr
-                        )
-                    keyboard.type_text(stripped)
-                    if should_submit:
-                        keyboard.press_enter()
-                else:
-                    # Submit word only — just press enter
-                    log("dispatch_enter", "(submit word only)")
-                    if DEBUG:
-                        print("  Wake word + submit word only [Enter]", file=sys.stderr)
-                    keyboard.press_enter()
+                log("wake_word_detected", command)
+                if DEBUG:
+                    print(f"  Wake word! Final: {command}", file=sys.stderr)
+                keyboard.type_text(command)
+                self._dispatch_result(command)
             if found and not command:
                 # Wake word only — enter ACTIVATED state for next utterance
                 log("wake_word_only", "Listening for command...")
@@ -367,7 +384,7 @@ class VoiceDaemon:
                 prob = self._vad.process(chunk)
 
                 if DEBUG:
-                    _print_vad_bar(prob, self._vad.threshold, self._state, chunk)
+                    _print_state(self._state)
 
                 if self._state == IDLE:
                     if prob > self._vad.threshold:

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.83.1",
+  version: "0.84.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -84,6 +84,7 @@ var runConfigSchema = z.strictObject({
   name: z.string(),
   command: z.string(),
   args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
   filter: z.string().optional()
 });
 var transcriptConfigSchema = z.strictObject({
@@ -91,6 +92,8 @@ var transcriptConfigSchema = z.strictObject({
   transcriptsDir: z.string(),
   summaryDir: z.string()
 });
+var DEFAULT_WAKE_WORDS = ["computer"];
+var DEFAULT_MODELS_DIR = "~/.assist/voice/models";
 var assistConfigSchema = z.strictObject({
   commit: z.strictObject({
     conventional: z.boolean().default(false),
@@ -126,18 +129,21 @@ var assistConfigSchema = z.strictObject({
   run: z.array(runConfigSchema).optional(),
   transcript: transcriptConfigSchema.optional(),
   voice: z.strictObject({
-    wakeWords: z.array(z.string()).default(["computer"]),
+    wakeWords: z.array(z.string()).default(DEFAULT_WAKE_WORDS),
     mic: z.string().optional(),
     cwd: z.string().optional(),
-    modelsDir: z.string().optional(),
+    modelsDir: z.string().default(DEFAULT_MODELS_DIR),
     lockDir: z.string().optional(),
-    submitWord: z.string().optional(),
+    submitWindows: z.array(z.string()).optional(),
     models: z.strictObject({
       vad: z.string().optional(),
-      smartTurn: z.string().optional(),
-      stt: z.string().optional()
-    }).optional()
-  }).optional()
+      smartTurn: z.string().optional()
+    }).default({})
+  }).default({
+    wakeWords: DEFAULT_WAKE_WORDS,
+    modelsDir: DEFAULT_MODELS_DIR,
+    models: {}
+  })
 });
 
 // src/shared/loadConfig.ts
@@ -1403,6 +1409,7 @@ function getRunEntries() {
   return run3.filter((r) => r.name.startsWith("verify:")).map((r) => ({
     name: r.name,
     fullCommand: buildFullCommand(r.command, r.args),
+    env: r.env,
     filter: r.filter
   }));
 }
@@ -1502,12 +1509,26 @@ function filterByChangedFiles(entries) {
 
 // src/commands/verify/run/spawnCommand.ts
 import { spawn } from "child_process";
+
+// src/shared/expandEnv.ts
+import { homedir as homedir2 } from "os";
+function expandTilde(value) {
+  return value.startsWith("~/") ? homedir2() + value.slice(1) : value;
+}
+function expandEnv(env) {
+  return Object.fromEntries(
+    Object.entries(env).map(([k, v]) => [k, expandTilde(v)])
+  );
+}
+
+// src/commands/verify/run/spawnCommand.ts
 var isClaudeCode = !!process.env.CLAUDECODE;
-function spawnCommand(fullCommand, cwd) {
+function spawnCommand(fullCommand, cwd, env) {
   return spawn(fullCommand, [], {
     stdio: isClaudeCode ? "pipe" : "inherit",
     shell: true,
-    cwd: cwd ?? process.cwd()
+    cwd: cwd ?? process.cwd(),
+    env: env ? { ...process.env, ...expandEnv(env) } : void 0
   });
 }
 function collectOutput(child) {
@@ -1526,7 +1547,7 @@ function flushIfFailed(exitCode, chunks) {
 // src/commands/verify/run/index.ts
 function runEntry(entry, onComplete) {
   return new Promise((resolve3) => {
-    const child = spawnCommand(entry.fullCommand, entry.cwd);
+    const child = spawnCommand(entry.fullCommand, entry.cwd, entry.env);
     const chunks = collectOutput(child);
     child.on("close", (code) => {
       const exitCode = code ?? 1;
@@ -2952,9 +2973,9 @@ import chalk37 from "chalk";
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync, readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import { join as join11 } from "path";
-var DEVLOG_DIR = join11(homedir2(), "git/blog/src/content/devlog");
+var DEVLOG_DIR = join11(homedir3(), "git/blog/src/content/devlog");
 function loadDevlogEntries(repoName) {
   const entries = /* @__PURE__ */ new Map();
   try {
@@ -5306,11 +5327,11 @@ import { spawnSync as spawnSync3 } from "child_process";
 import { join as join24 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { dirname as dirname17, join as join23 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname5 = dirname17(fileURLToPath4(import.meta.url));
-var VOICE_DIR = join23(homedir3(), ".assist", "voice");
+var VOICE_DIR = join23(homedir4(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
   pid: join23(VOICE_DIR, "voice.pid"),
@@ -5441,26 +5462,8 @@ import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync19 } from "fs";
 import { join as join27 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
-var ENV_MAP = {
-  VOICE_WAKE_WORDS: (v) => v.wakeWords?.join(","),
-  VOICE_MIC: (v) => v.mic,
-  VOICE_CWD: (v) => v.cwd,
-  VOICE_MODELS_DIR: (v) => v.modelsDir,
-  VOICE_MODEL_VAD: (v) => v.models?.vad,
-  VOICE_MODEL_SMART_TURN: (v) => v.models?.smartTurn,
-  VOICE_MODEL_STT: (v) => v.models?.stt,
-  VOICE_SUBMIT_WORD: (v) => v.submitWord
-};
 function buildDaemonEnv(options2) {
-  const config = loadConfig();
   const env = { ...process.env };
-  const voice = config.voice;
-  if (voice) {
-    for (const [key, getter] of Object.entries(ENV_MAP)) {
-      const value = getter(voice);
-      if (value) env[key] = value;
-    }
-  }
   env.VOICE_LOG_FILE = voicePaths.log;
   if (options2?.debug) env.VOICE_DEBUG = "1";
   return env;
@@ -5903,8 +5906,12 @@ function onSpawnError(err) {
   console.error(`Failed to execute command: ${err.message}`);
   process.exit(1);
 }
-function spawnCommand2(fullCommand) {
-  const child = spawn5(fullCommand, [], { stdio: "inherit", shell: true });
+function spawnCommand2(fullCommand, env) {
+  const child = spawn5(fullCommand, [], {
+    stdio: "inherit",
+    shell: true,
+    env: env ? { ...process.env, ...expandEnv(env) } : void 0
+  });
   child.on("close", (code) => process.exit(code ?? 0));
   child.on("error", onSpawnError);
 }
@@ -5917,7 +5924,10 @@ function listRunConfigs() {
 }
 function run2(name, args) {
   const runConfig = findRunConfig(name);
-  spawnCommand2(buildCommand(runConfig.command, runConfig.args ?? [], args));
+  spawnCommand2(
+    buildCommand(runConfig.command, runConfig.args ?? [], args),
+    runConfig.env
+  );
 }
 
 // src/commands/statusLine.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.83.1",
+	"version": "0.84.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {