use std::path::PathBuf;
use anyhow::Result;
use clap::Parser;
use tokio_util::sync::CancellationToken;
use corex_core::client::{get_sudo_password, LlmClient, StreamEvent};
use corex_core::config::Config;
use corex_core::session::Session;
use corex_core::types::{Message, ToolCall};
use corex_prompt::PromptBuilder;
use corex_tools::registry::ToolRegistry;
use corex_tools::types::ToolContext;
use corex_tui::{run_tui, App};
#[derive(Parser, Debug)]
#[command(
name = "cx",
version = env!("CARGO_PKG_VERSION"),
author = "sluisr <contact@sluisr.com>",
about = "Corex — High-Performance Autonomous Coding Agent"
)]
struct Cli {
#[arg(short = 'p', long = "prompt", alias = "message")]
message: Option<String>,
#[arg(trailing_var_arg = true)]
query: Vec<String>,
#[arg(short = 'w', long = "web")]
web: Option<String>,
#[arg(short = 'm', short_alias = 'M', long = "model")]
model: Option<String>,
#[arg(long)]
base_url: Option<String>,
#[arg(long)]
api_key: Option<String>,
#[arg(short = 'r', long)]
resume: Option<String>,
#[arg(short = 'l', long = "list-sessions")]
list_sessions: bool,
#[arg(short = 'y', long)]
yolo: bool,
#[arg(short = 'C', long)]
directory: Option<PathBuf>,
#[arg(long, default_missing_value = "true", num_args = 0..=1)]
local: Option<bool>,
#[arg(long)]
local_url: Option<String>,
#[arg(long)]
local_model: Option<String>,
}
pub async fn run() -> Result<()> {
let cli = Cli::parse();
let workspace_dir = cli
.directory
.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
if cli.list_sessions {
let ws_str = workspace_dir.display().to_string();
let sessions = Session::list_all(Some(&ws_str));
if sessions.is_empty() {
println!("No previous sessions found for this project.");
} else {
println!("\nAvailable sessions for this project ({}):", sessions.len());
for (i, s) in sessions.iter().enumerate() {
let rel_time = Session::format_relative_time(s.updated_at);
let tag_str = s.tag.as_ref().map(|t| format!(" [tag: {}]", t)).unwrap_or_default();
let model_display = if s.model == "deepseek-flash" || s.model == "deepseek-v4.1-flash" || s.model == "deepseek-v4-flash" || s.model == "deepseek-chat" {
"DeepSeek-V4.1-Flash"
} else if s.model == "deepseek-v4-pro" || s.model == "deepseek-reasoner" {
"DeepSeek-V4-Pro"
} else if s.model == "deepseek-v4-flash-vision-exp" {
"DeepSeek-V4.1-Flash (Vision)"
} else {
&s.model
};
println!(" {}. {} ({}){} · {} [{}]", i + 1, s.title, rel_time, tag_str, model_display, s.id);
}
println!("\nResume any session with: cx --resume <index | tag | id>\n");
}
return Ok(());
}
if cli.message.is_none() && cli.query.len() == 1 && (cli.query[0] == "update" || cli.query[0] == "--update") {
let current = env!("CARGO_PKG_VERSION");
println!("Checking for Corex updates...");
if let Some(newer) = corex_core::update::check_for_update_online(current).await {
println!("\nUpdate available: v{} → v{}\n", current, newer);
println!("To update Corex, run in your terminal:");
println!(" • Via npm: npm install -g @sluisr/corex");
println!(" • From source: cargo install --git https://github.com/sluisr/corex.git --force");
println!(" • Or download precompiled binaries from:");
println!(" https://github.com/sluisr/corex/releases/latest\n");
} else {
println!("Corex is already on the latest version (v{}).", current);
}
return Ok(());
}
let log_path = corex_core::ForensicLogger::init(Some(&workspace_dir));
tracing::debug!("Forensic audit logger initialized at {:?}", log_path);
let mut config = Config::load_with_workspace(Some(&workspace_dir));
let mut headless_prompt = cli.message.clone();
if let Some(m) = cli.model {
if (m.contains(' ') || m.ends_with('?') || m.starts_with("arregla") || m.starts_with("que ") || m.starts_with("fix"))
&& headless_prompt.is_none()
{
headless_prompt = Some(m);
} else {
config.model = m;
}
}
if let Some(u) = cli.base_url {
config.base_url = u;
}
if let Some(k) = cli.api_key {
config.api_key = k;
}
if let Some(loc_en) = cli.local {
config.local_llm_enabled = loc_en;
}
if let Some(loc_url) = cli.local_url {
config.local_llm_url = loc_url;
}
if let Some(loc_m) = cli.local_model {
config.local_llm_model = loc_m;
}
if cli.yolo {
config.yolo_mode = true;
}
let llm_client = LlmClient::new(config.clone());
let web_search_query = cli.web.or_else(|| {
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") {
let q = cli.query[1..].join(" ");
if !q.is_empty() {
Some(q)
} else {
None
}
} else {
None
}
});
if let Some(query) = web_search_query {
let prompt = format!(
"Por favor busca en internet usando la herramienta web_search y responde de manera clara, directa y sintetizada con fuentes a: {}",
query
);
let display = format!("/web {}", query);
run_headless(llm_client, workspace_dir, prompt, Some(display), config.yolo_mode).await?;
return Ok(());
}
if headless_prompt.is_none() && !cli.query.is_empty() {
headless_prompt = Some(cli.query.join(" "));
}
if let Some(prompt_text) = headless_prompt {
run_headless(llm_client, workspace_dir, prompt_text, None, config.yolo_mode).await?;
return Ok(());
}
let mut app = App::new(llm_client, workspace_dir.clone(), cli.yolo);
let _ = app.reload_mcp_servers().await;
if let Some(session_id) = cli.resume {
match Session::load_by_id_or_tag(&session_id) {
Ok(loaded) => {
let mut cfg = app.llm_client.get_config();
cfg.model = loaded.model.clone();
if let Some(t) = loaded.temperature {
cfg.temperature = t;
}
if let Some(ref r) = loaded.reasoning_effort {
cfg.reasoning_effort = r.clone();
}
app.llm_client.update_config(cfg);
app.session = loaded;
}
Err(e) => {
eprintln!("Warning: Could not resume session {}: {}. Starting new session.", session_id, e);
}
}
}
run_tui(app).await?;
Ok(())
}
async fn run_headless(
client: LlmClient,
workspace_dir: PathBuf,
user_prompt: String,
display_prompt: Option<String>,
yolo: bool,
) -> Result<()> {
let mut tool_registry = ToolRegistry::new();
let (mcp_tools, _) = corex_tools::load_mcp_servers(&client.get_config().mcp_servers).await;
for t in mcp_tools {
tool_registry.register(t);
}
let prompt_builder = PromptBuilder::new(&workspace_dir)
.with_sudo_password(get_sudo_password().is_some());
let mut messages = vec![
Message::system(prompt_builder.build()),
Message::user(user_prompt.clone()),
];
println!("You: {}", display_prompt.as_deref().unwrap_or(&user_prompt));
let tools = tool_registry.list_definitions();
let context = ToolContext {
workspace_dir: workspace_dir.clone(),
yolo_mode: yolo,
sudo_password: get_sudo_password(),
allowed_commands: client.get_config().allowed_commands.clone(),
};
use std::io::IsTerminal;
let is_tty = std::io::stdout().is_terminal();
let term_width = crossterm::terminal::size().map(|(w, _)| w as usize).unwrap_or(80);
struct StatusSpinner {
stop_tx: Option<tokio::sync::oneshot::Sender<()>>,
handle: Option<tokio::task::JoinHandle<()>>,
}
impl StatusSpinner {
fn start(is_tty: bool, prefix_color: &'static str, message: String) -> Self {
if !is_tty {
return Self { stop_tx: None, handle: None };
}
let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();
let handle = tokio::spawn(async move {
let frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
let mut i = 0;
loop {
print!("\r\x1b[2K{}{}\x1b[0m {}", prefix_color, frames[i], message);
use std::io::Write;
let _ = std::io::stdout().flush();
i = (i + 1) % frames.len();
tokio::select! {
_ = &mut rx => break,
_ = tokio::time::sleep(tokio::time::Duration::from_millis(70)) => {}
}
}
print!("\r\x1b[2K");
use std::io::Write;
let _ = std::io::stdout().flush();
});
Self {
stop_tx: Some(tx),
handle: Some(handle),
}
}
async fn stop(&mut self) {
if let Some(tx) = self.stop_tx.take() {
let _ = tx.send(());
}
if let Some(handle) = self.handle.take() {
let _ = handle.await;
}
print!("\r\x1b[2K");
use std::io::Write;
let _ = std::io::stdout().flush();
}
}
const MAX_HEADLESS_TURNS: usize = 35;
let mut turn_count = 0;
loop {
turn_count += 1;
if turn_count > MAX_HEADLESS_TURNS {
eprintln!("\n[WARNING] Maximum headless tool iteration limit ({}) reached. Terminating loop to protect budget.", MAX_HEADLESS_TURNS);
break;
}
let cancel_token = CancellationToken::new();
let mut rx = client
.stream_chat(messages.clone(), Some(tools.clone()), cancel_token.clone())
.await?;
let mut current_tool_calls: Vec<ToolCall> = Vec::new();
let mut assistant_text = String::new();
let mut reasoning_text = String::new();
let mut current_extra_content: Option<serde_json::Value> = None;
let mut active_spinner: Option<StatusSpinner> = None;
let mut current_stage: u8 = 0;
while let Some(event) = rx.recv().await {
match event {
StreamEvent::ReasoningDelta(delta) => {
reasoning_text.push_str(&delta);
if current_stage != 1 {
if let Some(mut s) = active_spinner.take() {
s.stop().await;
}
active_spinner = Some(StatusSpinner::start(
is_tty,
"\x1b[90m",
"Thinking...".to_string(),
));
current_stage = 1;
}
}
StreamEvent::ContentDelta(delta) => {
assistant_text.push_str(&delta);
if current_stage != 2 {
if let Some(mut s) = active_spinner.take() {
s.stop().await;
}
active_spinner = Some(StatusSpinner::start(
is_tty,
"\x1b[36m",
"Generating response...".to_string(),
));
current_stage = 2;
}
}
StreamEvent::ToolCallDelta { index, id, name, arguments, extra_content } => {
while current_tool_calls.len() <= index {
current_tool_calls.push(ToolCall {
id: String::new(),
call_type: "function".to_string(),
function: corex_core::types::FunctionCall {
name: String::new(),
arguments: String::new(),
},
extra_content: None,
});
}
if let Some(i) = id {
current_tool_calls[index].id.push_str(&i);
}
if let Some(n) = name {
current_tool_calls[index].function.name.push_str(&n);
}
if let Some(a) = arguments {
current_tool_calls[index].function.arguments.push_str(&a);
}
if let Some(ec) = extra_content {
current_tool_calls[index].extra_content = Some(ec);
}
}
StreamEvent::ExtraContentDelta(ec) => {
current_extra_content = Some(ec);
}
StreamEvent::Notice(msg) => {
if let Some(mut s) = active_spinner.take() {
s.stop().await;
}
println!("\n[INFO] {}\n", msg);
}
StreamEvent::ContextCompacted { notice, .. } => {
if let Some(mut s) = active_spinner.take() {
s.stop().await;
}
println!("\n[INFO] {}\n", notice);
}
StreamEvent::Completed { .. } => {}
StreamEvent::Error(err) => {
if let Some(mut s) = active_spinner.take() {
s.stop().await;
}
eprintln!("\nError: {}", err);
return Ok(());
}
_ => {}
}
}
if let Some(mut s) = active_spinner.take() {
s.stop().await;
}
if !assistant_text.trim().is_empty() {
if is_tty {
let theme = corex_tui::Theme::default();
let rendered = corex_tui::render_markdown_to_ansi(&assistant_text, &theme, term_width);
println!("{}\n", rendered);
} else {
println!("{}\n", assistant_text);
}
}
if !current_tool_calls.is_empty() {
let text_opt = if assistant_text.is_empty() { None } else { Some(assistant_text) };
let cot_opt = if reasoning_text.is_empty() { None } else { Some(reasoning_text) };
for call in &mut current_tool_calls {
if call.extra_content.is_none() {
call.extra_content = current_extra_content.clone();
}
}
messages.push(Message::assistant_with_tools(
text_opt,
cot_opt,
current_tool_calls.clone(),
));
for call in ¤t_tool_calls {
let args_json = corex_core::parse_lenient_json(&call.function.arguments)
.unwrap_or(serde_json::Value::Null);
let (action_label, target_detail) = if call.function.name == "run_shell_command" || call.function.name == "shell" || call.function.name == "run_command" {
let cmd = args_json.get("command").and_then(|c| c.as_str()).unwrap_or("").trim();
("Running command", cmd)
} else if call.function.name == "read_file" {
let p = args_json.get("path").or_else(|| args_json.get("file_path")).and_then(|c| c.as_str()).unwrap_or("");
("Reading file", p)
} else if call.function.name == "write_file" {
let p = args_json.get("path").or_else(|| args_json.get("file_path")).and_then(|c| c.as_str()).unwrap_or("");
("Writing file", p)
} else if call.function.name == "edit" || call.function.name == "apply_patch" {
let p = args_json.get("path").or_else(|| args_json.get("file_path")).and_then(|c| c.as_str()).unwrap_or("");
("Editing file", p)
} else if call.function.name == "glob" || call.function.name == "ls" || call.function.name == "list_directory" {
let p = args_json.get("path").or_else(|| args_json.get("dir")).and_then(|c| c.as_str()).unwrap_or(".");
("Exploring directory", p)
} else if call.function.name == "web_search" || call.function.name == "google_web_search" {
let q = args_json.get("query").and_then(|c| c.as_str()).unwrap_or("");
("Searching web", q)
} else if call.function.name == "web_fetch" {
let u = args_json.get("url").and_then(|c| c.as_str()).unwrap_or("");
("Fetching web page", u)
} else {
("Running tool", call.function.name.as_str())
};
let display_detail = corex_core::truncate_ellipsis(&corex_core::sanitize_for_terminal(target_detail), 70);
if !context.yolo_mode {
if let Some(tool) = tool_registry.get(&call.function.name) {
if tool.needs_confirmation(&args_json, &context) {
if is_tty {
print!("\r\x1b[2K");
use std::io::Write;
let _ = std::io::stdout().flush();
}
println!("\n[WARNING] Action requires confirmation: [{}]", call.function.name);
if let Some(diff) = tool.format_diff(&args_json, &context.workspace_dir) {
println!("{}", diff);
} else if let Some(cmd) = args_json.get("command").and_then(|c| c.as_str()) {
println!(" Command: {}", corex_core::sanitize_for_terminal(cmd));
} else {
println!(" Arguments: {}", corex_core::sanitize_for_terminal(&serde_json::to_string_pretty(&args_json).unwrap_or_default()));
}
print!("Allow execution? [y/N]: ");
use std::io::Write;
let _ = std::io::stdout().flush();
let mut input = String::new();
let _ = std::io::stdin().read_line(&mut input);
let trimmed = input.trim().to_lowercase();
if trimmed != "y" && trimmed != "yes" {
println!("Execution cancelled by user.");
messages.push(Message::tool_response(call.id.clone(), "Execution denied by user."));
continue;
}
}
}
}
let mut tool_spinner = StatusSpinner::start(
is_tty,
"\x1b[33m",
format!("\x1b[1m{}:\x1b[0m \x1b[36m{}\x1b[0m", action_label, display_detail),
);
let output = match tool_registry
.execute(&call.function.name, args_json, &context)
.await
{
Ok(o) => {
tool_spinner.stop().await;
if is_tty {
println!("\x1b[32m✓\x1b[0m \x1b[1m{}\x1b[0m: \x1b[90m{}\x1b[0m", action_label, display_detail);
}
o.output
}
Err(e) => {
tool_spinner.stop().await;
if is_tty {
println!("\x1b[31m✗\x1b[0m \x1b[1m{}\x1b[0m: \x1b[90m{}\x1b[0m ({})", action_label, display_detail, e);
}
let msg = format!("Error executing {}: {}", call.function.name, e);
eprintln!("{}", msg);
msg
}
};
messages.push(Message::tool_response(call.id.clone(), output));
}
continue;
}
break;
}
Ok(())
}