Skip to main content

corex_cli/
lib.rs

1use std::path::PathBuf;
2use anyhow::Result;
3use clap::Parser;
4use tokio_util::sync::CancellationToken;
5
6use corex_core::client::{get_sudo_password, LlmClient, StreamEvent};
7use corex_core::config::Config;
8use corex_core::session::Session;
9use corex_core::types::{Message, ToolCall};
10use corex_prompt::PromptBuilder;
11use corex_tools::registry::ToolRegistry;
12use corex_tools::types::ToolContext;
13use corex_tui::{run_tui, App};
14
15#[derive(Parser, Debug)]
16#[command(
17    name = "cx",
18    version = env!("CARGO_PKG_VERSION"),
19    author = "sluisr <contact@sluisr.com>",
20    about = "Corex — High-Performance Autonomous Coding Agent"
21)]
22struct Cli {
23    /// Non-interactive headless prompt to execute directly (e.g. -p "..." or --prompt "...")
24    #[arg(short = 'p', long = "prompt", alias = "message")]
25    message: Option<String>,
26
27    /// Positional query (if provided without -p, runs headlessly)
28    #[arg(trailing_var_arg = true)]
29    query: Vec<String>,
30
31    /// Perform live web search using DeepSeek native search engine (e.g. -w "query" or --web "query")
32    #[arg(short = 'w', long = "web")]
33    web: Option<String>,
34
35    /// Model name override (e.g. -m deepseek-flash, --model deepseek-v4-pro)
36    #[arg(short = 'm', short_alias = 'M', long = "model")]
37    model: Option<String>,
38
39    /// Custom API base URL (e.g. https://api.deepseek.com)
40    #[arg(long)]
41    base_url: Option<String>,
42
43    /// API Key override
44    #[arg(long)]
45    api_key: Option<String>,
46
47    /// Resume a previously saved conversation session by ID, tag, or index
48    #[arg(short = 'r', long)]
49    resume: Option<String>,
50
51    /// List available conversation sessions for this project
52    #[arg(short = 'l', long = "list-sessions")]
53    list_sessions: bool,
54
55    /// Automatically approve all tool executions (YOLO mode)
56    #[arg(short = 'y', long)]
57    yolo: bool,
58
59    /// Working directory (defaults to current working directory)
60    #[arg(short = 'C', long)]
61    directory: Option<PathBuf>,
62
63    /// Enable or disable local LLM assistant (--local, --no-local)
64    #[arg(long, default_missing_value = "true", num_args = 0..=1)]
65    local: Option<bool>,
66
67    /// Custom Local LLM URL (default: http://127.0.0.1:8080/v1)
68    #[arg(long)]
69    local_url: Option<String>,
70
71    /// Custom Local LLM model name
72    #[arg(long)]
73    local_model: Option<String>,
74
75}
76
77pub async fn run() -> Result<()> {
78    let cli = Cli::parse();
79
80    let workspace_dir = cli
81        .directory
82        .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
83
84    // Handle --list-sessions directly
85    if cli.list_sessions {
86        let ws_str = workspace_dir.display().to_string();
87        let sessions = Session::list_all(Some(&ws_str));
88        if sessions.is_empty() {
89            println!("No previous sessions found for this project.");
90        } else {
91            println!("\nAvailable sessions for this project ({}):", sessions.len());
92            for (i, s) in sessions.iter().enumerate() {
93                let rel_time = Session::format_relative_time(s.updated_at);
94                let tag_str = s.tag.as_ref().map(|t| format!(" [tag: {}]", t)).unwrap_or_default();
95                let model_display = if s.model == "deepseek-flash" || s.model == "deepseek-v4.1-flash" || s.model == "deepseek-v4-flash" || s.model == "deepseek-chat" {
96                    "DeepSeek-V4.1-Flash"
97                } else if s.model == "deepseek-v4-pro" || s.model == "deepseek-reasoner" {
98                    "DeepSeek-V4-Pro"
99                } else if s.model == "deepseek-v4-flash-vision-exp" {
100                    "DeepSeek-V4.1-Flash (Vision)"
101                } else {
102                    &s.model
103                };
104                println!("  {}. {} ({}){} · {} [{}]", i + 1, s.title, rel_time, tag_str, model_display, s.id);
105            }
106            println!("\nResume any session with: cx --resume <index | tag | id>\n");
107        }
108        return Ok(());
109    }
110
111    // Handle "cx update" command directly
112    if cli.message.is_none() && cli.query.len() == 1 && (cli.query[0] == "update" || cli.query[0] == "--update") {
113        let current = env!("CARGO_PKG_VERSION");
114        println!("Checking for Corex updates...");
115        if let Some(newer) = corex_core::update::check_for_update_online(current).await {
116            println!("\nUpdate available: v{} → v{}\n", current, newer);
117            println!("To update Corex, run in your terminal:");
118            println!("  • Via npm:       npm install -g @sluisr/corex");
119            println!("  • From source:   cargo install --git https://github.com/sluisr/corex.git --force");
120            println!("  • Or download precompiled binaries from:");
121            println!("    https://github.com/sluisr/corex/releases/latest\n");
122        } else {
123            println!("Corex is already on the latest version (v{}).", current);
124        }
125        return Ok(());
126    }
127
128    // Initialize forensic audit log system (~/.corex/logs/corex-forensic-YYYY-MM-DD.log)
129    let log_path = corex_core::ForensicLogger::init(Some(&workspace_dir));
130    tracing::debug!("Forensic audit logger initialized at {:?}", log_path);
131
132    let mut config = Config::load_with_workspace(Some(&workspace_dir));
133    let mut headless_prompt = cli.message.clone();
134
135    if let Some(m) = cli.model {
136        // Smart fallback: If a sentence with spaces or question mark was passed to --model, treat as headless prompt!
137        if (m.contains(' ') || m.ends_with('?') || m.starts_with("arregla") || m.starts_with("que ") || m.starts_with("fix"))
138            && headless_prompt.is_none()
139        {
140            headless_prompt = Some(m);
141        } else {
142            config.model = m;
143        }
144    }
145    if let Some(u) = cli.base_url {
146        config.base_url = u;
147    }
148    if let Some(k) = cli.api_key {
149        config.api_key = k;
150    }
151    if let Some(loc_en) = cli.local {
152        config.local_llm_enabled = loc_en;
153    }
154    if let Some(loc_url) = cli.local_url {
155        config.local_llm_url = loc_url;
156    }
157    if let Some(loc_m) = cli.local_model {
158        config.local_llm_model = loc_m;
159    }
160    if cli.yolo {
161        config.yolo_mode = true;
162    }
163
164    let llm_client = LlmClient::new(config.clone());
165
166    // Handle standalone --web / -w or `cx web <query>` search query
167    let web_search_query = cli.web.or_else(|| {
168        if cli.message.is_none() && !cli.query.is_empty() && (cli.query[0] == "web" || cli.query[0] == "/web" || cli.query[0] == "search" || cli.query[0] == "/search") {
169            let q = cli.query[1..].join(" ");
170            if !q.is_empty() {
171                Some(q)
172            } else {
173                None
174            }
175        } else {
176            None
177        }
178    });
179
180    if let Some(query) = web_search_query {
181        let prompt = format!(
182            "Por favor busca en internet usando la herramienta web_search y responde de manera clara, directa y sintetizada con fuentes a: {}",
183            query
184        );
185        let display = format!("/web {}", query);
186        run_headless(llm_client, workspace_dir, prompt, Some(display), config.yolo_mode).await?;
187        return Ok(());
188    }
189
190    // Check if headless mode requested via -m, -p, or positional args
191    if headless_prompt.is_none() && !cli.query.is_empty() {
192        headless_prompt = Some(cli.query.join(" "));
193    }
194
195    if let Some(prompt_text) = headless_prompt {
196        run_headless(llm_client, workspace_dir, prompt_text, None, config.yolo_mode).await?;
197        return Ok(());
198    }
199
200    // Launch interactive TUI
201    let mut app = App::new(llm_client, workspace_dir.clone(), cli.yolo);
202    let _ = app.reload_mcp_servers().await;
203    if let Some(session_id) = cli.resume {
204        match Session::load_by_id_or_tag(&session_id) {
205            Ok(loaded) => {
206                let mut cfg = app.llm_client.get_config();
207                cfg.model = loaded.model.clone();
208                if let Some(t) = loaded.temperature {
209                    cfg.temperature = t;
210                }
211                if let Some(ref r) = loaded.reasoning_effort {
212                    cfg.reasoning_effort = r.clone();
213                }
214                app.llm_client.update_config(cfg);
215                app.session = loaded;
216            }
217            Err(e) => {
218                eprintln!("Warning: Could not resume session {}: {}. Starting new session.", session_id, e);
219            }
220        }
221    }
222
223    run_tui(app).await?;
224    Ok(())
225}
226
227async fn run_headless(
228    client: LlmClient,
229    workspace_dir: PathBuf,
230    user_prompt: String,
231    display_prompt: Option<String>,
232    yolo: bool,
233) -> Result<()> {
234    let mut tool_registry = ToolRegistry::new();
235    let (mcp_tools, _) = corex_tools::load_mcp_servers(&client.get_config().mcp_servers).await;
236    for t in mcp_tools {
237        tool_registry.register(t);
238    }
239    let prompt_builder = PromptBuilder::new(&workspace_dir)
240        .with_sudo_password(get_sudo_password().is_some());
241
242    let mut messages = vec![
243        Message::system(prompt_builder.build()),
244        Message::user(user_prompt.clone()),
245    ];
246
247    println!("You: {}", display_prompt.as_deref().unwrap_or(&user_prompt));
248
249    let tools = tool_registry.list_definitions();
250    let context = ToolContext {
251        workspace_dir: workspace_dir.clone(),
252        yolo_mode: yolo,
253        sudo_password: get_sudo_password(),
254        allowed_commands: client.get_config().allowed_commands.clone(),
255    };
256
257    use std::io::IsTerminal;
258    let is_tty = std::io::stdout().is_terminal();
259    let term_width = crossterm::terminal::size().map(|(w, _)| w as usize).unwrap_or(80);
260
261    struct StatusSpinner {
262        stop_tx: Option<tokio::sync::oneshot::Sender<()>>,
263        handle: Option<tokio::task::JoinHandle<()>>,
264    }
265
266    impl StatusSpinner {
267        fn start(is_tty: bool, prefix_color: &'static str, message: String) -> Self {
268            if !is_tty {
269                return Self { stop_tx: None, handle: None };
270            }
271            let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();
272            let handle = tokio::spawn(async move {
273                let frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
274                let mut i = 0;
275                loop {
276                    print!("\r\x1b[2K{}{}\x1b[0m {}", prefix_color, frames[i], message);
277                    use std::io::Write;
278                    let _ = std::io::stdout().flush();
279                    i = (i + 1) % frames.len();
280                    tokio::select! {
281                        _ = &mut rx => break,
282                        _ = tokio::time::sleep(tokio::time::Duration::from_millis(70)) => {}
283                    }
284                }
285                print!("\r\x1b[2K");
286                use std::io::Write;
287                let _ = std::io::stdout().flush();
288            });
289            Self {
290                stop_tx: Some(tx),
291                handle: Some(handle),
292            }
293        }
294
295        async fn stop(&mut self) {
296            if let Some(tx) = self.stop_tx.take() {
297                let _ = tx.send(());
298            }
299            if let Some(handle) = self.handle.take() {
300                let _ = handle.await;
301            }
302            print!("\r\x1b[2K");
303            use std::io::Write;
304            let _ = std::io::stdout().flush();
305        }
306    }
307
308    const MAX_HEADLESS_TURNS: usize = 35;
309    let mut turn_count = 0;
310
311    loop {
312        turn_count += 1;
313        if turn_count > MAX_HEADLESS_TURNS {
314            eprintln!("\n[WARNING] Maximum headless tool iteration limit ({}) reached. Terminating loop to protect budget.", MAX_HEADLESS_TURNS);
315            break;
316        }
317
318        let cancel_token = CancellationToken::new();
319        let mut rx = client
320            .stream_chat(messages.clone(), Some(tools.clone()), cancel_token.clone())
321            .await?;
322
323        let mut current_tool_calls: Vec<ToolCall> = Vec::new();
324        let mut assistant_text = String::new();
325        let mut reasoning_text = String::new();
326        let mut current_extra_content: Option<serde_json::Value> = None;
327        let mut active_spinner: Option<StatusSpinner> = None;
328        let mut current_stage: u8 = 0; // 0 = idle, 1 = reasoning, 2 = content
329
330        while let Some(event) = rx.recv().await {
331            match event {
332                StreamEvent::ReasoningDelta(delta) => {
333                    reasoning_text.push_str(&delta);
334                    if current_stage != 1 {
335                        if let Some(mut s) = active_spinner.take() {
336                            s.stop().await;
337                        }
338                        active_spinner = Some(StatusSpinner::start(
339                            is_tty,
340                            "\x1b[90m",
341                            "Thinking...".to_string(),
342                        ));
343                        current_stage = 1;
344                    }
345                }
346                StreamEvent::ContentDelta(delta) => {
347                    assistant_text.push_str(&delta);
348                    if current_stage != 2 {
349                        if let Some(mut s) = active_spinner.take() {
350                            s.stop().await;
351                        }
352                        active_spinner = Some(StatusSpinner::start(
353                            is_tty,
354                            "\x1b[36m",
355                            "Generating response...".to_string(),
356                        ));
357                        current_stage = 2;
358                    }
359                }
360                StreamEvent::ToolCallDelta { index, id, name, arguments, extra_content } => {
361                    while current_tool_calls.len() <= index {
362                        current_tool_calls.push(ToolCall {
363                            id: String::new(),
364                            call_type: "function".to_string(),
365                            function: corex_core::types::FunctionCall {
366                                name: String::new(),
367                                arguments: String::new(),
368                            },
369                            extra_content: None,
370                        });
371                    }
372                    if let Some(i) = id {
373                        current_tool_calls[index].id.push_str(&i);
374                    }
375                    if let Some(n) = name {
376                        current_tool_calls[index].function.name.push_str(&n);
377                    }
378                    if let Some(a) = arguments {
379                        current_tool_calls[index].function.arguments.push_str(&a);
380                    }
381                    if let Some(ec) = extra_content {
382                        current_tool_calls[index].extra_content = Some(ec);
383                    }
384                }
385                StreamEvent::ExtraContentDelta(ec) => {
386                    current_extra_content = Some(ec);
387                }
388                StreamEvent::Notice(msg) => {
389                    if let Some(mut s) = active_spinner.take() {
390                        s.stop().await;
391                    }
392                    println!("\n[INFO] {}\n", msg);
393                }
394                StreamEvent::ContextCompacted { notice, .. } => {
395                    if let Some(mut s) = active_spinner.take() {
396                        s.stop().await;
397                    }
398                    println!("\n[INFO] {}\n", notice);
399                }
400                StreamEvent::Completed { .. } => {}
401                StreamEvent::Error(err) => {
402                    if let Some(mut s) = active_spinner.take() {
403                        s.stop().await;
404                    }
405                    eprintln!("\nError: {}", err);
406                    return Ok(());
407                }
408                _ => {}
409            }
410        }
411
412        if let Some(mut s) = active_spinner.take() {
413            s.stop().await;
414        }
415
416        if !assistant_text.trim().is_empty() {
417            if is_tty {
418                let theme = corex_tui::Theme::default();
419                let rendered = corex_tui::render_markdown_to_ansi(&assistant_text, &theme, term_width);
420                println!("{}\n", rendered);
421            } else {
422                println!("{}\n", assistant_text);
423            }
424        }
425
426        if !current_tool_calls.is_empty() {
427            let text_opt = if assistant_text.is_empty() { None } else { Some(assistant_text) };
428            let cot_opt = if reasoning_text.is_empty() { None } else { Some(reasoning_text) };
429
430            for call in &mut current_tool_calls {
431                if call.extra_content.is_none() {
432                    call.extra_content = current_extra_content.clone();
433                }
434            }
435
436            messages.push(Message::assistant_with_tools(
437                text_opt,
438                cot_opt,
439                current_tool_calls.clone(),
440            ));
441
442            for call in &current_tool_calls {
443                let args_json = corex_core::parse_lenient_json(&call.function.arguments)
444                    .unwrap_or(serde_json::Value::Null);
445
446                let (action_label, target_detail) = if call.function.name == "run_shell_command" || call.function.name == "shell" || call.function.name == "run_command" {
447                    let cmd = args_json.get("command").and_then(|c| c.as_str()).unwrap_or("").trim();
448                    ("Running command", cmd)
449                } else if call.function.name == "read_file" {
450                    let p = args_json.get("path").or_else(|| args_json.get("file_path")).and_then(|c| c.as_str()).unwrap_or("");
451                    ("Reading file", p)
452                } else if call.function.name == "write_file" {
453                    let p = args_json.get("path").or_else(|| args_json.get("file_path")).and_then(|c| c.as_str()).unwrap_or("");
454                    ("Writing file", p)
455                } else if call.function.name == "edit" || call.function.name == "apply_patch" {
456                    let p = args_json.get("path").or_else(|| args_json.get("file_path")).and_then(|c| c.as_str()).unwrap_or("");
457                    ("Editing file", p)
458                } else if call.function.name == "glob" || call.function.name == "ls" || call.function.name == "list_directory" {
459                    let p = args_json.get("path").or_else(|| args_json.get("dir")).and_then(|c| c.as_str()).unwrap_or(".");
460                    ("Exploring directory", p)
461                } else if call.function.name == "web_search" || call.function.name == "google_web_search" {
462                    let q = args_json.get("query").and_then(|c| c.as_str()).unwrap_or("");
463                    ("Searching web", q)
464                } else if call.function.name == "web_fetch" {
465                    let u = args_json.get("url").and_then(|c| c.as_str()).unwrap_or("");
466                    ("Fetching web page", u)
467                } else {
468                    ("Running tool", call.function.name.as_str())
469                };
470
471                let display_detail = corex_core::truncate_ellipsis(&corex_core::sanitize_for_terminal(target_detail), 70);
472
473                // Prompt user for confirmation on potentially mutating/dangerous actions unless YOLO mode is enabled
474                if !context.yolo_mode {
475                    if let Some(tool) = tool_registry.get(&call.function.name) {
476                        if tool.needs_confirmation(&args_json, &context) {
477                            if is_tty {
478                                print!("\r\x1b[2K");
479                                use std::io::Write;
480                                let _ = std::io::stdout().flush();
481                            }
482                            println!("\n[WARNING] Action requires confirmation: [{}]", call.function.name);
483                            if let Some(diff) = tool.format_diff(&args_json, &context.workspace_dir) {
484                                println!("{}", diff);
485                            } else if let Some(cmd) = args_json.get("command").and_then(|c| c.as_str()) {
486                                println!("  Command: {}", corex_core::sanitize_for_terminal(cmd));
487                            } else {
488                                println!("  Arguments: {}", corex_core::sanitize_for_terminal(&serde_json::to_string_pretty(&args_json).unwrap_or_default()));
489                            }
490
491                            print!("Allow execution? [y/N]: ");
492                            use std::io::Write;
493                            let _ = std::io::stdout().flush();
494
495                            let mut input = String::new();
496                            let _ = std::io::stdin().read_line(&mut input);
497                            let trimmed = input.trim().to_lowercase();
498                            if trimmed != "y" && trimmed != "yes" {
499                                println!("Execution cancelled by user.");
500                                messages.push(Message::tool_response(call.id.clone(), "Execution denied by user."));
501                                continue;
502                            }
503                        }
504                    }
505                }
506
507                // Show real-time animated spinner while the tool executes
508                let mut tool_spinner = StatusSpinner::start(
509                    is_tty,
510                    "\x1b[33m",
511                    format!("\x1b[1m{}:\x1b[0m \x1b[36m{}\x1b[0m", action_label, display_detail),
512                );
513
514                let output = match tool_registry
515                    .execute(&call.function.name, args_json, &context)
516                    .await
517                {
518                    Ok(o) => {
519                        tool_spinner.stop().await;
520                        if is_tty {
521                            println!("\x1b[32m✓\x1b[0m \x1b[1m{}\x1b[0m: \x1b[90m{}\x1b[0m", action_label, display_detail);
522                        }
523                        o.output
524                    }
525                    Err(e) => {
526                        tool_spinner.stop().await;
527                        if is_tty {
528                            println!("\x1b[31m✗\x1b[0m \x1b[1m{}\x1b[0m: \x1b[90m{}\x1b[0m ({})", action_label, display_detail, e);
529                        }
530                        let msg = format!("Error executing {}: {}", call.function.name, e);
531                        eprintln!("{}", msg);
532                        msg
533                    }
534                };
535                messages.push(Message::tool_response(call.id.clone(), output));
536            }
537
538            // Feed the tool results back and continue the agent loop
539            continue;
540        }
541
542        // No tool calls: the assistant's final answer has been fully streamed
543        break;
544    }
545
546    Ok(())
547}