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 #[arg(short = 'p', long = "prompt", alias = "message")]
25 message: Option<String>,
26
27 #[arg(trailing_var_arg = true)]
29 query: Vec<String>,
30
31 #[arg(short = 'w', long = "web")]
33 web: Option<String>,
34
35 #[arg(short = 'm', short_alias = 'M', long = "model")]
37 model: Option<String>,
38
39 #[arg(long)]
41 base_url: Option<String>,
42
43 #[arg(long)]
45 api_key: Option<String>,
46
47 #[arg(short = 'r', long)]
49 resume: Option<String>,
50
51 #[arg(short = 'l', long = "list-sessions")]
53 list_sessions: bool,
54
55 #[arg(short = 'y', long)]
57 yolo: bool,
58
59 #[arg(short = 'C', long)]
61 directory: Option<PathBuf>,
62
63 #[arg(long, default_missing_value = "true", num_args = 0..=1)]
65 local: Option<bool>,
66
67 #[arg(long)]
69 local_url: Option<String>,
70
71 #[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 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 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 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 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 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 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 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; 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 ¤t_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 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 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 continue;
540 }
541
542 break;
544 }
545
546 Ok(())
547}