Command Mode: voice-triggered inline assistant (rewrite selection, clipboard context, Q&A)

[DevEmperor]

Idea adopted from WonderWhisper (dkapo88/WonderWhisper).

Summary

Add a spoken command mode: when a dictation starts with a trigger word (e.g. "command", configurable), the utterance is not inserted verbatim — instead it is treated as an instruction to an LLM that acts on the current context and inserts the result. This turns dictation into an inline voice assistant, reusing the rewording pipeline we already have.

Supported actions

• Rewrite the selected text — "command make this more formal", "command translate to English". Uses the current text selection as the target (we already read selection for rewording prompts with requiresSelection).
• Use the clipboard as context — "command reply to this", "command summarize this". The clipboard content is passed to the model as context. (This is the standalone clipboard-context idea; useful on its own.)
• Answer a question — "command what's the capital of Japan" → inserts the answer directly in the field.
• General transformations — free-form instruction applied to selection/clipboard/none.

Why

Today rewording is prompt-bar driven (tap a preset). A voice trigger removes the tap and makes ad-hoc, one-off instructions possible without predefining a prompt. Related but distinct from #14 (style prompt using context) and #10 (chat history for contextual input) — those are about passive context, this is an explicit spoken command.

Notes / implementation pointers

• Detect the trigger word at the start of the transcript (locale-aware; make the word configurable, allow disabling).
• Route the remainder through the existing rewording/chat path (OpenAiCompatibleClient.complete), building the user content from: instruction + optional selection + optional clipboard.
• Decide selection- vs clipboard- vs no-context by simple heuristics (selection present → rewrite; else clipboard non-empty and instruction references "this" → clipboard; else plain Q&A).
• Guard against empty/echo results like the existing auto-format guard (Auto-formatting spills the master prompt into the field on empty recognition #124).
• Keep it opt-in.

[MyButtermilk]

@DevEmperor : I love how you are inspired by WonderWhisper with several new feature ideas! : )

[grapefruit89]

Hey @DevEmperor,

I really like this app and want to help the developer avoid burnout, so I try to jump in and help out with troubleshooting wherever I can!

Note

(Full transparency: I used the Google Antigravity desktop version equipped with MCP servers to clone and deeply analyze this repo locally, which helped me quickly trace the architecture for this proposal.)

This Command Mode idea is an absolute game-changer. Since you've already built the entire LLM routing (requestReword) and the "Live Prompt" toggle logic, integrating the voice-triggered Command Mode is incredibly straightforward. It fits perfectly into DictateController.kt right where finalizeAndCommit processes the raw transcript.

Here is the exact architectural extension you need to make the voice trigger, selection reading, and clipboard context work seamlessly together:

1. Add a Clipboard Helper

We need a small helper in DictateController.kt to read the clipboard text safely. Because Dictate operates as an IME or Accessibility Service, it already has the necessary window focus to read the clipboard on Android 10+ without issues.

private fun getSystemClipboardText(context: Context): String? {
    val clipboard = context.getSystemService(ClipboardManager::class.java) ?: return null
    if (!clipboard.hasPrimaryClip()) return null
    val clip = clipboard.primaryClip ?: return null
    if (clip.itemCount == 0) return null
    return clip.getItemAt(0).text?.toString()
}

2. Intercept the Command in finalizeAndCommit

We can simply check the rawText for the trigger word at the very start of the finalizeAndCommit function. If it matches, we strip the trigger, fetch the context (selection or clipboard), and hijack the existing live prompt execution path!

// In DictateController.kt -> finalizeAndCommit()
val triggerWord = prefs.dictate.commandTriggerWord.get().trim()
val isVoiceCommand = triggerWord.isNotBlank() && 
                     rawText.lowercase().startsWith(triggerWord.lowercase())

val finalText = if (live || isVoiceCommand) {
    // The dictation is an instruction; send it to GPT
    _pendingPrompts.value = emptyList() // a live prompt ignores any queued prompts
    _state.value = UiState.Rewording(appContext.getString(R.string.dictate__status_rewording))
    
    val instruction = if (isVoiceCommand) {
        // Strip the trigger word and leading punctuation (e.g., "Command, translate this")
        rawText.substring(triggerWord.length).trim().trimStart(',', ':', '-', ' ').trim()
    } else {
        rawText
    }
    
    val selection = sink(appContext).selectedText().takeIf { it.isNotEmpty() }
    
    // Resolve context: Selection > Clipboard > None
    val input = if (selection != null) {
        selection
    } else {
        val clipboardText = getSystemClipboardText(appContext)
        // Heuristic: If there's no selection, but they say "this" and clipboard isn't empty
        if (clipboardText != null && instruction.lowercase().contains("this")) {
            clipboardText
        } else {
            null
        }
    }
    
    requestReword(instruction, input)
} else {
    // Normal dictation: auto-formatting + auto-apply prompts...
    val processed = if (alreadyFormatted) rawText else postProcessTranscript(appContext, rawText)
    applyPendingPrompts(appContext, processed)
}

With this setup, if a user dictates "Command, reply to this and make it sound professional", the app automatically pulls the clipboard content, feeds it to the LLM as input along with the voice instruction, and inserts the generated email response right where the cursor is!

P.S. @DevEmperor I want to emphasize that my intention here is not to act like a know-it-all or dictate how you should develop your app. I'm simply a huge fan of this project, it's one of the most important apps I use daily, and I just want to help bring visibility to these issues so you can focus on the core development! "Why should I still type when there is Dictate?" – this app is probably the reason why phones will shrink again in the next 10 years!