stt-cli 0.2.1

Speech to text Cli using Groq API and OpenAI API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// src/platform/handler.rs
// Implements a handler that bridges TextInserter with the TranscriptionResultHandler trait.

pub trait TextInserter: Send + Sync {
    fn insert_text_with_options(
        &mut self,
        text: &str,
        options: InsertOptions,
    ) -> anyhow::Result<()>;
}

#[derive(Default, Debug, Clone)]
pub struct InsertOptions {
    pub auto_capitalize: bool,
    pub auto_punctuate: bool,
    // Add more options as needed
}

use crate::transcription::result_handler::TranscriptionResultHandler;
use anyhow::Result;

pub struct PlatformTextInserterHandler {
    inserter: Box<dyn TextInserter + Send + Sync>,
}

impl PlatformTextInserterHandler {
    pub fn new(inserter: Box<dyn TextInserter + Send + Sync>) -> Self {
        Self { inserter }
    }
}

impl TranscriptionResultHandler for PlatformTextInserterHandler {
    fn handle_result(&mut self, text: &str, options: InsertOptions) -> Result<()> {
        self.inserter.insert_text_with_options(text, options)
    }
}

// Stub implementation for development/testing
pub struct StubTextInserter;

impl TextInserter for StubTextInserter {
    fn insert_text_with_options(
        &mut self,
        text: &str,
        options: InsertOptions,
    ) -> anyhow::Result<()> {
        println!(
            "[StubTextInserter] Would insert text: {} with options: {:?}",
            text, options
        );
        Ok(())
    }
}

// --- Enigo-based TextInserter Implementation ---
use enigo::{Enigo, Settings, Keyboard};

pub struct EnigoTextInserter {
    enigo: Enigo,
}

impl EnigoTextInserter {
    pub fn new() -> anyhow::Result<Self> {
        // TODO: all this extra codes does not seem to help at the moment. 
        #[cfg(target_os = "linux")]
        {
            use std::env;
            let display = env::var("DISPLAY").ok();
            let wayland = env::var("WAYLAND_DISPLAY").ok();

            match (display.as_deref(), wayland.as_deref()) {
                (Some(_), Some(_)) => {
                    // Both are set: prefer X11 (DISPLAY)
                    let orig = env::var("WAYLAND_DISPLAY").ok();
                    env::remove_var("WAYLAND_DISPLAY");
                    let enigo = Enigo::new(&Settings::default())?;
                    // Restore WAYLAND_DISPLAY for rest of app
                    if let Some(val) = orig { env::set_var("WAYLAND_DISPLAY", val); }
                    Ok(Self { enigo })
                }
                (Some(_), None) => {
                    // Only X11
                    let enigo = Enigo::new(&Settings::default())?;
                    Ok(Self { enigo })
                }
                (None, Some(_)) => {
                    // Only Wayland
                    let enigo = Enigo::new(&Settings::default())?;
                    Ok(Self { enigo })
                }
                (None, None) => {
                    anyhow::bail!("Neither DISPLAY nor WAYLAND_DISPLAY is set. Cannot select Enigo backend.");
                }
            }
        }
        #[cfg(target_os = "macos")]
        {
            let enigo = Enigo::new(&Settings::default())?;
            Ok(Self { enigo })
        }
        #[cfg(target_os = "windows")]
        {
            let enigo = Enigo::new(&Settings::default())?;
            Ok(Self { enigo })
        }
        #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
        {
            anyhow::bail!("EnigoTextInserter is not supported on this platform.");
        }
    }
}

impl TextInserter for EnigoTextInserter {
    fn insert_text_with_options(
        &mut self,
        text: &str,
        options: InsertOptions,
    ) -> anyhow::Result<()> {
        // Optionally process text with options here (auto_capitalize, auto_punctuate)
        let processed_text = text; // TODO: apply options if needed
        self.enigo.text(processed_text)?;
        Ok(())
    }
}