feat(res): add Confirmer resource and stdin args setup

Add Confirmer with cached confirmation state and predicate-based
parsing for yes/no and true/false inputs. Add ConfirmerSetup to
register the resource and auto-confirm when skip mode is enabled.
Add StandardInputArgsSetup to read piped stdin as appended arguments.
Reorganize module exports in res and setups.

2 files changed, 142 insertions, 0 deletions

diff --git a/mingling/src/setups/confirmer.rs b/mingling/src/setups/confirmer.rs
new file mode 100644
index 0000000..1824745
--- /dev/null
+++ b/mingling/src/setups/confirmer.rs
@@ -0,0 +1,60 @@
+use mingling_core::{
+    Program, ProgramCollect, config, hook::ProgramHook, setup::ProgramSetup, this,
+};
+
+use crate::res::Confirmer;
+
+/// Confirmer setup for managing confirmation state
+///
+/// This Setup manages the confirmation flag within the program's resource
+/// store. It registers a [`Confirmer`] resource and sets up a hook that
+/// checks the user's confirmation mode during program execution.
+///
+/// # Usage
+///
+/// This Setup can be registered using the
+/// [`Program`](https://docs.rs/mingling/latest/mingling/struct.Program.html)
+/// `with_setup` method, for example:
+///
+/// ```rust
+/// # use mingling::MockProgramCollect as ThisProgram;
+/// use mingling::Program;
+/// use mingling::setup::ConfirmerSetup;
+///
+/// let mut program = Program::<ThisProgram>::new();
+/// program.with_setup(ConfirmerSetup);
+/// ```
+///
+/// # Behavior
+///
+/// - Registers a [`Confirmer`] resource that tracks confirmation state.
+/// - At the beginning of command execution, checks whether the user's
+///   confirmation mode is set to `Skip`.
+/// - If confirmation is skipped, the [`Confirmer`] resource is updated
+///   to record the confirmed state.
+///
+/// # Notes
+///
+/// - This Setup applies uniformly to all subcommands of the entire program.
+/// - The confirmation state is determined by the global `config` setting;
+///   it does not support per-command overrides.
+pub struct ConfirmerSetup;
+
+impl<C> ProgramSetup<C> for ConfirmerSetup
+where
+    C: ProgramCollect<Enum = C> + 'static,
+{
+    fn setup(self, program: &mut Program<C>) {
+        program.with_resource(Confirmer::new());
+
+        program.with_hook(ProgramHook::empty().on_pre_dispatch::<_, ()>(|_| {
+            let p = this::<C>();
+            let confirmed = p.user_context.confirmation == config::ConfirmationMode::Skip;
+            if confirmed {
+                p.modify_res(|c: &mut Confirmer| {
+                    c.set_confirmed();
+                });
+            }
+        }));
+    }
+}
diff --git a/mingling/src/setups/stdin_args.rs b/mingling/src/setups/stdin_args.rs
new file mode 100644
index 0000000..ca55ca7
--- /dev/null
+++ b/mingling/src/setups/stdin_args.rs
@@ -0,0 +1,82 @@
+use std::io::{IsTerminal, Read};
+
+use mingling_core::{
+    Program, ProgramCollect, hook::ProgramHook, setup::ProgramSetup, utils::ArgumentSplitter,
+};
+
+/// Uses the standard input as arguments for the program
+///
+/// This Setup can take standard input supplied via a pipe or redirect,
+/// split it according to whitespace and quoting rules, and append
+/// the resulting arguments to the end of the command argument list.
+///
+/// # Usage
+///
+/// This Setup can be registered using the
+/// [`Program`](https://docs.rs/mingling/latest/mingling/struct.Program.html)
+/// `with_setup` method, for example:
+///
+/// ```rust
+/// # use mingling::MockProgramCollect as ThisProgram;
+/// use mingling::Program;
+/// use mingling::setup::StandardInputArgsSetup;
+///
+/// let mut program = Program::<ThisProgram>::new();
+/// program.with_setup(StandardInputArgsSetup);
+/// ```
+///
+/// # Behavior
+///
+/// - Standard input is only read when it is not a terminal (i.e., when
+///   there is piped or redirected input).
+/// - The read content is split into multiple arguments according to
+///   whitespace and quoting rules.
+/// - If the standard input content is empty, no arguments are produced.
+/// - All input is converted to UTF-8 encoding (lossy conversion is used
+///   when strict parsing is not possible).
+///
+/// # Notes
+///
+/// - This Setup applies uniformly to all subcommands of the entire program
+///   and does not provide fine-grained control. If you need different
+///   standard input behavior across different subcommands (e.g., some
+///   subcommands read stdin while others ignore it), **do not use this Setup**.
+/// - This Setup does **not** provide any validation rules. Content provided
+///   via standard input is treated as trusted arguments and appended directly.
+///   As a result, the input source can also inject arbitrary arguments into
+///   the command, so you should be careful when processing untrusted input.
+pub struct StandardInputArgsSetup;
+
+impl<C> ProgramSetup<C> for StandardInputArgsSetup
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        program.with_hook(ProgramHook::empty().on_pre_dispatch(|ctx| {
+            let pipe_input = read_stdin();
+            if let Some(pipe_input) = pipe_input {
+                ctx.arguments.append(&mut pipe_input.trim().split_args());
+            }
+        }));
+    }
+}
+
+fn read_stdin() -> Option<String> {
+    // Check if stdin is a terminal (no piped input) or has data available
+    if std::io::stdin().is_terminal() {
+        return None;
+    }
+
+    let mut bytes = Vec::new();
+    match std::io::stdin().read_to_end(&mut bytes) {
+        Ok(_) => {
+            if bytes.is_empty() {
+                return None;
+            }
+            // Handle encoding differences, ensure output is always UTF-8.
+            // First try strict UTF-8 parsing; fall back to lossy conversion
+            Some(String::from_utf8_lossy(&bytes).into_owned())
+        }
+        Err(_) => None,
+    }
+}