#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![warn(clippy::missing_errors_doc)]
#![warn(clippy::missing_panics_doc)]
#![warn(rustdoc::missing_crate_level_docs)]
#![warn(rustdoc::broken_intra_doc_links)]
#![warn(rustdoc::private_intra_doc_links)]
#![deny(rustdoc::invalid_html_tags)]
#![deny(rustdoc::invalid_rust_codeblocks)]
#![deny(rustdoc::bare_urls)]
#![warn(rustdoc::redundant_explicit_links)]
#![cfg_attr(docsrs, feature(doc_cfg))]
pub mod agent_ops;
pub mod cache;
pub mod cli;
pub mod concurrency;
pub mod config;
pub mod crates_io;
pub mod diagnostics;
mod dispatch;
pub mod docs_rs;
mod doctor;
pub mod domain;
pub mod error;
pub mod http;
pub mod i18n;
pub mod item_kind;
mod meta_cmds;
mod ops;
mod output;
pub mod platform;
pub mod render;
pub mod retry;
pub mod shutdown;
mod suggest;
use std::io::{self, IsTerminal, Write};
use std::process::ExitCode;
use clap::Parser;
use crate::agent_ops::AgentOps;
use crate::cli::Cli;
use crate::cli::overrides::apply_cli_overrides;
use crate::config::Config;
use crate::diagnostics::init_tracing;
use crate::dispatch::execute;
use crate::error::{AppError, EXIT_BROKEN_PIPE, EXIT_USAGE, ErrorDetail, ErrorKind};
use crate::i18n::Locale;
use crate::render::error_envelope;
use crate::shutdown::flush_stdio;
fn argv_wants_json_mode(args: &[std::ffi::OsString], stdout_is_terminal: bool) -> bool {
let has_json = args.iter().any(|a| a == "--json");
let has_human_format = args.windows(2).any(|w| {
w[0] == "--format"
&& w[1]
.to_str()
.is_some_and(|v| v == "text" || v == "markdown" || v == "md")
}) || args.iter().any(|a| {
a.to_str().is_some_and(|s| {
s.starts_with("--format=")
&& (s.contains("text") || s.contains("markdown") || s.contains("md"))
})
});
if has_json {
return true;
}
if has_human_format {
return false;
}
!stdout_is_terminal
}
pub async fn run<I, T>(args: I) -> ExitCode
where
I: IntoIterator<Item = T>,
T: Into<std::ffi::OsString> + Clone,
{
let stdout_is_terminal = io::stdout().is_terminal();
run_with_io(
args,
io::stdin(),
io::stdout(),
io::stderr(),
stdout_is_terminal,
)
.await
}
pub async fn run_with_io<I, T, In, Out, ErrW>(
args: I,
_stdin: In,
mut stdout: Out,
mut stderr: ErrW,
stdout_is_terminal: bool,
) -> ExitCode
where
I: IntoIterator<Item = T>,
T: Into<std::ffi::OsString> + Clone,
In: io::Read,
Out: Write,
ErrW: Write,
{
let args: Vec<std::ffi::OsString> = args.into_iter().map(Into::into).collect();
let agent_json = argv_wants_json_mode(&args, stdout_is_terminal);
let cli = match Cli::try_parse_from(&args) {
Ok(c) => c,
Err(e) => {
if !e.use_stderr() {
let _ = e.print();
flush_stdio();
return ExitCode::SUCCESS;
}
let msg = e.to_string();
if agent_json {
let err = AppError::of(ErrorDetail::ClapUsage { message: msg });
let _ = output::write_json(&mut stdout, &error_envelope(&err, "usage", 0));
flush_stdio();
return ExitCode::from(EXIT_USAGE);
}
let _ = e.print();
flush_stdio();
return ExitCode::from(EXIT_USAGE);
}
};
let code = match run_cli(cli, &mut stdout, &mut stderr, stdout_is_terminal).await {
Ok(code) => code,
Err(err) if err.kind() == ErrorKind::BrokenPipe => ExitCode::from(EXIT_BROKEN_PIPE),
Err(err) => {
tracing::error!(
target: "docsrs_cli::diagnostics",
error = %err,
kind = ?err.kind(),
"error escaped structured emit path"
);
let locale = Locale::from_argv_for_bootstrap(&args);
let _ = writeln!(stderr, "{}", locale.format_error(&err));
err.exit_code()
}
};
flush_stdio();
let _ = stdout.flush();
let _ = stderr.flush();
code
}
async fn run_cli<Out: Write, ErrW: Write>(
cli: Cli,
stdout: &mut Out,
stderr: &mut ErrW,
stdout_is_terminal: bool,
) -> Result<ExitCode, AppError> {
let wire = cli.wire_command();
let early_locale = cli
.lang
.as_deref()
.map(Locale::soft_from_tag)
.unwrap_or_else(Locale::from_system);
if let Err(e) = cli.validate_format_conflict() {
return Ok(meta_cmds::emit_error(
&cli,
&e,
early_locale,
stdout,
stderr,
stdout_is_terminal,
wire,
0,
));
}
let mut cfg = match Config::load_with_options(
cli.config_dir.clone(),
cli.cache_dir.clone(),
cli.allow_loopback,
) {
Ok(c) => c,
Err(e) => {
return Ok(meta_cmds::emit_error(
&cli,
&e,
early_locale,
stdout,
stderr,
stdout_is_terminal,
wire,
0,
));
}
};
init_tracing(&cli, cfg.log_directive.as_deref());
let cfg_locale = cli
.lang
.as_deref()
.or(cfg.lang.as_deref())
.map_or(early_locale, Locale::soft_from_tag);
if let Err(e) = apply_cli_overrides(&cli, &mut cfg) {
return Ok(meta_cmds::emit_error(
&cli,
&e,
cfg_locale,
stdout,
stderr,
stdout_is_terminal,
wire,
0,
));
}
let locale = match Locale::resolve(cli.lang.as_deref().or(cfg.lang.as_deref())) {
Ok(l) => l,
Err(e) => {
return Ok(meta_cmds::emit_error(
&cli,
&e,
Locale::En,
stdout,
stderr,
stdout_is_terminal,
wire,
0,
));
}
};
let ops = match AgentOps::from_cli(&cli) {
Ok(o) => o,
Err(e) => {
return Ok(meta_cmds::emit_error(
&cli,
&e,
locale,
stdout,
stderr,
stdout_is_terminal,
wire,
0,
));
}
};
if !(ops.is_active() && cli.wants_json(stdout_is_terminal)) {
return Ok(execute(&cli, &cfg, locale, stdout, stderr, stdout_is_terminal, wire).await);
}
let mut captured: Vec<u8> = Vec::new();
let code = execute(
&cli,
&cfg,
locale,
&mut captured,
stderr,
stdout_is_terminal,
wire,
)
.await;
let reduced = ops.apply_to_bytes(&captured);
if !reduced.is_empty() && stdout.write_all(&reduced).is_err() {
return Ok(ExitCode::from(EXIT_BROKEN_PIPE));
}
let _ = stdout.flush();
Ok(code)
}