@goodandready/dsh-voice 0.9.30 → 0.9.32

package/lib/dictation-modes.js

@@ -0,0 +1,28 @@
+// lib/dictation-modes.js — Dictation post-processing modes (#264)
+
+export const DICTATION_MODES = ['verbatim', 'clean', 'task', 'note']
+
+export const DEFAULT_DICTATION_PROMPTS = {
+  clean: 'Fix the punctuation and spelling of this dictated text and remove filler words ("um", "uh", etc.). Keep the original language, technical terms, and meaning intact without adding facts. Reply with the clean text only:\n\n{text}',
+  task: 'Convert the following dictated request into a clear, structured agent task with: Problem/Goal, Expected Outcome, Constraints, Acceptance Criteria. Do not invent details not mentioned in the dictation. Keep technical identifiers intact. Reply with the structured task only:\n\n{text}',
+  note: 'Extract key points, main ideas, and action items from the following dictation. Only include action items that were explicitly mentioned. Keep original terminology intact. Reply with the structured note only:\n\n{text}',
+}
+
+/**
+ * Resolve prompt instruction for a dictation sub-mode.
+ * @param {string} mode 'verbatim' | 'clean' | 'task' | 'note'
+ * @param {Record<string, string>} [customPrompts]
+ * @param {string} text Dictated text to format
+ * @returns {string|null} null for verbatim (0 LLM calls), prompt string for LLM modes
+ */
+export function resolveDictationPrompt(mode, customPrompts, text) {
+  const m = DICTATION_MODES.includes(mode) ? mode : 'clean'
+  if (m === 'verbatim') return null
+  const template = (customPrompts && typeof customPrompts[m] === 'string' && customPrompts[m].trim())
+    ? customPrompts[m]
+    : DEFAULT_DICTATION_PROMPTS[m]
+  if (template.includes('{text}')) {
+    return template.replaceAll('{text}', text)
+  }
+  return template + '\n\n' + text
+}

package/lib/host-routes.js

@@ -1,25 +1,41 @@
-// lib/host-routes.js — Host HTTP routes for dsh-voice status, polish, and transcribe
-import { writeJson, readBody, isTrustedCaller } from './http-util.js'
+// HTTP host routes registered on ctx.webServer.
+import { readBody, isLoopback, isTrustedCaller } from './http-util.js'
 import { resolveSensevoiceProvider } from './sensevoice-installer.js'
+import { applyVoiceMacros } from './macros.js'
 
-export function registerHostRoutes(ctx, {
-  live,
-  daemons,
-  statsTracker,
-  transcribe,
-  polishText,
-  sessionCommand,
-  extractVoiceActions,
-  applyJargonDictionary,
-  KNOWN_KEYS,
-}) {
-  const { whisperAlive, sensevoiceAlive, getWhisperError, getSensevoiceError, startWhisper, startSensevoice } = daemons
+function writeJson(res, status, obj) {
+  res.writeHead(status, { 'content-type': 'application/json' })
+  res.end(JSON.stringify(obj))
+}
+
+export function registerHostRoutes(ctx, deps) {
+  const {
+    live,
+    daemons,
+    statsTracker,
+    transcribe,
+    polishText,
+    sessionCommand,
+    extractVoiceActions,
+    applyJargonDictionary,
+    KNOWN_KEYS,
+  } = deps
+
+  const {
+    whisperAlive,
+    sensevoiceAlive,
+    getWhisperError,
+    getSensevoiceError,
+    startWhisper,
+    startSensevoice,
+  } = daemons
 
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/status',
     handler: async (req, res) => {
       if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      if (!isTrustedCaller(req)) { writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden source origin' } }); return }
       const cfg = live()
       const whisperOk = await whisperAlive()
       const sensevoiceOk = await sensevoiceAlive()
@@ -47,7 +63,7 @@ export function registerHostRoutes(ctx, {
           message: {
             chain: cfg.message.chain, language: cfg.message.language,
             autoSendMs: cfg.message.autoSendMs, polish: cfg.message.polish,
-            sessionCommands: cfg.message.sessionCommands, polishSend: cfg.message.polishSend,
+            sessionCommands: cfg.message.sessionCommands, polishSend: cfg.message.polishSend, editablePreview: cfg.message.editablePreview !== false,
           },
         },
         beep: cfg.beep,
@@ -76,6 +92,9 @@ export function registerHostRoutes(ctx, {
         jargonDictionary: Array.isArray(cfg.jargonDictionary) ? cfg.jargonDictionary : [],
         liveInterimPreview: cfg.liveInterimPreview !== false,
         structuredPromptVoice: cfg.structuredPromptVoice !== false,
+        dictationMode: cfg.dictationMode || 'clean',
+        dictationPrompts: cfg.dictationPrompts || {},
+        voiceMacros: Array.isArray(cfg.voiceMacros) ? cfg.voiceMacros : [],
         providerStats: statsTracker.get(),
       })
     },
@@ -101,11 +120,13 @@ export function registerHostRoutes(ctx, {
       try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { /* empty */ }
       const text = typeof payload.text === 'string' ? payload.text.trim() : ''
       if (!text) { writeJson(res, 400, { ok: false, error: { code: 'empty', message: 'text required' } }); return }
+      const subMode = payload.subMode || payload.dictationMode || cfg.dictationMode || 'clean'
+      const prompt = typeof payload.prompt === 'string' ? payload.prompt : null
       const controller = new AbortController()
       const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
       try {
-        const out = await polishText(text, { polish: true }, controller.signal)
-        writeJson(res, 200, { ok: true, text: out })
+        const out = await polishText(text, { polish: true, subMode, prompt }, controller.signal)
+        writeJson(res, 200, { ok: true, text: out, subMode })
       } catch (e) {
         writeJson(res, 502, { ok: false, error: { code: 'polish', message: String(e && e.message || e) } })
       } finally { clearTimeout(timer) }
@@ -165,7 +186,20 @@ export function registerHostRoutes(ctx, {
           const cmd = sessionCommand(out.text)
           if (cmd) { writeJson(res, 200, { ok: true, command: cmd, provider: out.provider, tookMs: out.tookMs }); return }
         }
-        let text = await polishText(out.text, modeCfg, controller.signal)
+        const subMode = payload.subMode || payload.dictationMode || cfg.dictationMode || 'clean'
+        const rawText = out.text
+        let text = out.text
+
+        // Dictation modes & polish (#264): verbatim skips LLM entirely (0 LLM calls)
+        if (subMode !== 'verbatim' && (modeCfg.polish === true || payload.polish === true)) {
+          text = await polishText(rawText, { ...modeCfg, subMode, prompt: payload.prompt }, controller.signal)
+        }
+
+        // Voice action macros (#167)
+        if (Array.isArray(cfg.voiceMacros) && cfg.voiceMacros.length > 0) {
+          text = applyVoiceMacros(text, cfg.voiceMacros)
+        }
+
         if (cfg.techJargonCorrection !== false) {
           text = applyJargonDictionary(text, cfg.jargonDictionary)
         }
@@ -177,7 +211,7 @@ export function registerHostRoutes(ctx, {
             action = actionRes.action
           }
         }
-        writeJson(res, 200, { ok: true, text, action, provider: out.provider, tookMs: out.tookMs })
+        writeJson(res, 200, { ok: true, text, rawText, subMode, action, provider: out.provider, tookMs: out.tookMs })
       } catch (e) {
         writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
       } finally {

package/lib/macros.js

@@ -0,0 +1,53 @@
+// lib/macros.js — Dynamic voice action macros parsing & substitution (#167)
+
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export function normalizeMacroPhrase(str) {
+  return String(str || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[.,!?:;]+$/g, '')
+    .replace(/^[.,!?:;]+/g, '')
+    .trim()
+}
+
+/**
+ * Apply configured voice macros to recognized text.
+ * @param {string} text Raw speech recognition output
+ * @param {Array<{trigger: string, template: string}>} macros Configured voice macros
+ * @returns {string} Substituted or original text
+ */
+export function applyVoiceMacros(text, macros) {
+  if (!text || !Array.isArray(macros) || macros.length === 0) return text
+  const cleanText = String(text).trim()
+  const normText = normalizeMacroPhrase(cleanText)
+
+  for (const macro of macros) {
+    if (!macro || typeof macro.trigger !== 'string' || !macro.template) continue
+    const trig = normalizeMacroPhrase(macro.trigger)
+    if (!trig) continue
+
+    // 1. Exact match
+    if (normText === trig) {
+      return macro.template.trim()
+    }
+
+    // 2. Prefix match
+    const trigWordBoundary = new RegExp('^' + escapeRegex(trig) + '(?:\\s+|[:,\\-]\\s*|$)', 'i')
+    if (trigWordBoundary.test(normText)) {
+      const rest = cleanText.slice(macro.trigger.length).replace(/^[\s,:\-]+/, '').trim()
+      let template = String(macro.template).trim()
+      if (template.includes('{{text}}') || template.includes('{text}') || template.includes('{input}')) {
+        return template
+          .replaceAll('{{text}}', rest)
+          .replaceAll('{text}', rest)
+          .replaceAll('{input}', rest)
+      }
+      return rest ? (template + '\n' + rest) : template
+    }
+  }
+
+  return cleanText
+}

package/lib/polish.js

@@ -1,4 +1,5 @@
 import { isLoopback } from './http-util.js'
+import { resolveDictationPrompt } from './dictation-modes.js'
 // Transcript polish. Pure factory: inject fetch, key resolver, LLM, config.
 // On any failure return the original text — polish must never block input.
 
@@ -14,6 +15,9 @@ export function createPolishText({ resolveKey, fetchImpl, getConfig, llm, getAge
   return async function polishText(text, modeCfg, signal) {
     const enable = modeCfg && (modeCfg.polish === true || modeCfg.polishSend === true)
     if (!enable || !text) return text
+    const subMode = (modeCfg && (modeCfg.subMode || modeCfg.dictationMode)) || 'clean'
+    if (subMode === 'verbatim') return text
+
     const cfg = getConfig() || {}
     if (cfg.localOnly) {
       if (!cfg.polishBaseUrl) return text
@@ -24,11 +28,15 @@ export function createPolishText({ resolveKey, fetchImpl, getConfig, llm, getAge
         return text
       }
     }
-    const ask =
-      'Fix the punctuation and spelling of this dictated text and split it into '
-      + 'paragraphs where the speaker changes topic. Remove filler words ("um", "uh", '
-      + '"ээ", "ну", "как бы"). Keep the original language, wording and meaning. '
-      + 'Reply with the polished text only:\n\n' + text
+
+    const customPrompts = (modeCfg && modeCfg.prompts) || cfg.dictationPrompts || {}
+    const customInstruction = (modeCfg && typeof modeCfg.prompt === 'string' && modeCfg.prompt.trim()) ? modeCfg.prompt : null
+    const ask = customInstruction
+      ? (customInstruction.includes('{text}') ? customInstruction.replaceAll('{text}', text) : `${customInstruction}\n\n${text}`)
+      : (resolveDictationPrompt(subMode, customPrompts, text) || text)
+
+    if (ask === text) return text
+
     try {
       // Local OpenAI-compatible endpoint when configured.
       if (cfg.polishBaseUrl) {
@@ -81,4 +89,4 @@ export function createPolishText({ resolveKey, fetchImpl, getConfig, llm, getAge
       return text
     }
   }
-}
+}

package/lib/providers.js

@@ -98,7 +98,9 @@ export function makeProviders(deps, req) {
     const model = pickModel(models, 'deepgram')
     const base = String(cfg.deepgramBaseUrl || 'https://api.deepgram.com').replace(/\/+$/, '')
     const url = `${base}/v1/listen?model=${encodeURIComponent(model)}`
-      + (!isAutoLang(lang) ? `&language=${encodeURIComponent(lang)}` : '') + '&smart_format=true'
+      + (!isAutoLang(lang) ? `&language=${encodeURIComponent(lang)}` : '')
+      + (vocab ? `&keywords=${encodeURIComponent(vocab)}` : '')
+      + '&smart_format=true'
     const res = await fetchImpl(url, {
       method: 'POST',
       headers: { authorization: `Token ${key}`, 'content-type': mime },

package/lib/schema.js

@@ -31,6 +31,10 @@ export const CustomProvider = z.object({
       + 'Empty means the built-in one.'),
 })
 
+export const VoiceMacro = z.object({
+  trigger: z.string().default(''),
+  template: z.string().default(''),
+})
 
 export const BaseConfig = z.object({
   dictation: z.object({
@@ -62,7 +66,8 @@ export const BaseConfig = z.object({
       .description('Cancel window before the recognized text is sent to the agent.'),
     sessionCommands: z.boolean().default(false)
       .description('Voice session commands: a clean "send", "cancel", "stop", "continue" does not become text — it drives the composer/session.'),
-    polishSend: z.boolean().default(false)
+    polishSend: z.boolean().default(false),
+    editablePreview: z.boolean().default(true)
       .description('Polish the whole composed draft through the model right before sending, not just single phrases.'),
   }).default({}),
   hotkey: z.string().default('Control')
@@ -155,6 +160,14 @@ export const BaseConfig = z.object({
     .description('Display real-time interim speech preview (ghost text) in the recording pill.'),
   structuredPromptVoice: z.boolean().default(true)
     .description('Target voice dictation and numeric choices to active DSH structured prompt modals.'),
+  dictationMode: z.union(['verbatim', 'clean', 'task', 'note']).default('clean')
+    .description('Dictation post-processing mode: "verbatim", "clean", "task", or "note".'),
+  dictationPrompts: z.object({
+    clean: z.string().default(''),
+    task: z.string().default(''),
+    note: z.string().default(''),
+  }).default({})
+    .description('Custom prompt templates for dictation modes.'),
+  voiceMacros: z.array(VoiceMacro).default([])
+    .description('User voice action macros (spoken trigger phrase -> structured prompt replacement).'),
 })
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.9.30",
+  "version": "0.9.32",
   "description": "Voice input for DeepSeek Harness: dictation chunked by pauses and voice messages, each with its own provider fallback chain (Deepgram, Groq, HuggingFace, local whisper.cpp, plus any OpenAI-compatible API of your own).",
   "license": "MIT",
   "type": "module",