limit-cli 0.0.46

AI-powered terminal coding assistant with TUI. Multi-provider LLM support, session persistence, and built-in tools.
Documentation 
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Tab operations

use crate::tools::browser::executor::BrowserError;
use crate::tools::browser::types::TabInfo;

/// Tab operations for browser client
pub trait TabsExt {
    /// List all browser tabs
    fn tab_list(
        &self,
    ) -> impl std::future::Future<Output = Result<Vec<TabInfo>, BrowserError>> + Send;

    /// Open a new tab, optionally with URL
    fn tab_new(
        &self,
        url: Option<&str>,
    ) -> impl std::future::Future<Output = Result<(), BrowserError>> + Send;

    /// Close a tab by index (or current if None)
    fn tab_close(
        &self,
        index: Option<usize>,
    ) -> impl std::future::Future<Output = Result<(), BrowserError>> + Send;

    /// Select/switch to a tab by index
    fn tab_select(
        &self,
        index: usize,
    ) -> impl std::future::Future<Output = Result<(), BrowserError>> + Send;

    /// Accept a dialog (alert, confirm, prompt) with optional text
    fn dialog_accept(
        &self,
        text: Option<&str>,
    ) -> impl std::future::Future<Output = Result<(), BrowserError>> + Send;

    /// Dismiss a dialog (alert, confirm, prompt)
    fn dialog_dismiss(&self) -> impl std::future::Future<Output = Result<(), BrowserError>> + Send;
}

impl TabsExt for super::super::BrowserClient {
    async fn tab_list(&self) -> Result<Vec<TabInfo>, BrowserError> {
        let output = self.executor().execute(&["tab", "list"]).await?;

        if output.success {
            let tabs = output
                .stdout
                .lines()
                .filter(|line| !line.is_empty())
                .enumerate()
                .map(|(i, line)| TabInfo {
                    index: i,
                    title: line.to_string(),
                })
                .collect();
            Ok(tabs)
        } else {
            Err(BrowserError::Other(format!(
                "Failed to list tabs: {}",
                output.stderr
            )))
        }
    }

    async fn tab_new(&self, url: Option<&str>) -> Result<(), BrowserError> {
        let output = if let Some(u) = url {
            self.executor().execute(&["tab", "new", u]).await?
        } else {
            self.executor().execute(&["tab", "new"]).await?
        };

        if output.success {
            Ok(())
        } else {
            Err(BrowserError::Other(format!(
                "Failed to open new tab: {}",
                output.stderr
            )))
        }
    }

    async fn tab_close(&self, index: Option<usize>) -> Result<(), BrowserError> {
        let output = if let Some(i) = index {
            let idx = i.to_string();
            self.executor().execute(&["tab", "close", &idx]).await?
        } else {
            self.executor().execute(&["tab", "close"]).await?
        };

        if output.success {
            Ok(())
        } else {
            Err(BrowserError::Other(format!(
                "Failed to close tab: {}",
                output.stderr
            )))
        }
    }

    async fn tab_select(&self, index: usize) -> Result<(), BrowserError> {
        let idx = index.to_string();
        let output = self.executor().execute(&["tab", "select", &idx]).await?;

        if output.success {
            Ok(())
        } else {
            Err(BrowserError::Other(format!(
                "Failed to select tab: {}",
                output.stderr
            )))
        }
    }

    async fn dialog_accept(&self, text: Option<&str>) -> Result<(), BrowserError> {
        let output = if let Some(t) = text {
            self.executor().execute(&["dialog", "accept", t]).await?
        } else {
            self.executor().execute(&["dialog", "accept"]).await?
        };

        if output.success {
            Ok(())
        } else {
            Err(BrowserError::Other(format!(
                "Failed to accept dialog: {}",
                output.stderr
            )))
        }
    }

    async fn dialog_dismiss(&self) -> Result<(), BrowserError> {
        let output = self.executor().execute(&["dialog", "dismiss"]).await?;

        if output.success {
            Ok(())
        } else {
            Err(BrowserError::Other(format!(
                "Failed to dismiss dialog: {}",
                output.stderr
            )))
        }
    }
}