mandible 0.1.2

mandible: a universal, interactive TUI reference for CLI tools. `mandible git` opens an explorable tree of every command, subcommand, and flag git has, with descriptions.
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

//! `mandible`: the binary. Wires the extraction pipeline, the cache, and the
//! TUI together; also hosts the non-interactive `--doctor` diagnostic.

#![forbid(unsafe_code)]

mod about;
mod app_runner;
mod background;
mod cli;
mod doctor;
mod pipeline;

use clap::{CommandFactory, Parser};
use cli::Cli;

fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_env("MANDIBLE_LOG"))
        .with_writer(std::io::stderr)
        .try_init()
        .ok();

    let cli = Cli::parse();

    if let Some(shell) = cli.completions {
        let mut cmd = Cli::command();
        let bin_name = cmd.get_name().to_string();
        clap_complete::generate(shell, &mut cmd, bin_name, &mut std::io::stdout());
        return Ok(());
    }

    let Some(tool) = cli.target_tool() else {
        anyhow::bail!("usage: mandible <tool>  (or: mandible --doctor <tool>)");
    };
    let tool = tool.to_string();

    // `mandible mandible` shows the about screen rather than extracting
    // the binary's own `--help`. Self-introspection is still available
    // through `mandible --doctor mandible`, which runs the real pipeline
    // against it — the form anyone actually wants for that purpose.
    if cli.doctor.is_none() && tool == env!("CARGO_PKG_NAME") {
        about::print();
        return Ok(());
    }

    if let Some(doctor_tool) = &cli.doctor {
        let loaded = pipeline::load(doctor_tool);
        let ok = loaded.root.is_some();
        doctor::print_report(&loaded);
        // Note: deliberately `anyhow::bail!` rather than
        // `std::process::exit`, so `std::process` stays confined to
        // `mandible-extract/src/exec/` workspace-wide (spec §6, §8) — even
        // though `exit` doesn't spawn anything, keeping the grep-based
        // invariant test literal and unambiguous is worth the minor
        // indirection.
        if !ok {
            anyhow::bail!("doctor: no extraction tier produced a result for {doctor_tool:?}");
        }
        return Ok(());
    }

    if !mandible_tui::terminal::stdout_is_tty() {
        anyhow::bail!(
            "mandible requires an interactive terminal (stdout is not a tty). \
             Try running it directly in a terminal, or use `mandible --doctor {tool}` \
             for a non-interactive report."
        );
    }

    // Startup does *no* extraction. Resolving the name on `PATH` is a
    // filesystem lookup with no subprocess spawn, so it stays here — it is
    // the one failure worth reporting on the command line rather than
    // inside a TUI the user then has to quit. Everything else, including
    // the root node's own `--help` probe, happens on the background warmer
    // once the first frame is already on screen.
    //
    // Blocking here is what made launching feel slow: extracting the root
    // synchronously cost ~1.1s for `gh` and ~0.7s for `docker` before a
    // single pixel was drawn, and the cobra-style tools where that matters
    // most are exactly the ones with the biggest trees.
    if mandible_extract::resolve_tool(&tool).path.is_none() {
        anyhow::bail!(
            "{tool:?} was not found on PATH. Run `mandible --doctor {tool}` for details on \
             what was tried."
        );
    }

    let stub = mandible_core::CommandNode::new(tool.clone(), mandible_core::Provenance::default());
    let app = mandible_tui::App::new(tool, stub);

    app_runner::run(app)
}