fix: integrate reviewed CLI and runtime fixes

Add an explicit --files list grammar for shell-expanded inputs while
preserving the established single and repeated -f behavior. This avoids
classifying positional prompt tokens by filesystem existence and makes the
file/prompt boundary explicit.

Apply command preludes before --info with defined REPL fallback semantics,
parse editor commands into an executable plus arguments without invoking a
shell, and reuse that parser for REPL buffer editing. Move local image reads
to Tokio, use the configured warning color for generated shell commands, and
document installation and local-agent layouts.

Adapt the bounded fixes discussed in:
sigoden#1451
sigoden#1509
sigoden#1534
sigoden#1533
sigoden#1512
sigoden#1525
sigoden#1383
sigoden#1437
sigoden#1486

Co-Authored-By: Codex CLI <noreply@openai.com>

Author: ei-grad

Cargo.toml

@@ -22,7 +22,7 @@ reedline = "0.40.0"
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = { version = "1.0.93", features = ["preserve_order"] }
 serde_yaml = "0.9.17"
-tokio = { version = "1.34.0", features = ["rt", "time", "macros", "signal", "rt-multi-thread"] }
+tokio = { version = "1.34.0", features = ["fs", "rt", "time", "macros", "signal", "rt-multi-thread"] }
 tokio-graceful = "0.2.2"
 tokio-stream = { version = "0.1.15", default-features = false, features = ["sync"] }
 crossterm = "0.28.1"

README.md

@@ -12,8 +12,10 @@ AIChat is an all-in-one LLM CLI tool featuring Shell Assistant, CMD & REPL Mode,
 
 - **Rust Developers:** `cargo install aichat`
 - **Homebrew/Linuxbrew Users:** `brew install aichat`
+- **[mise](https://mise.jdx.dev/) Users:** `mise use --global aqua:sigoden/aichat@latest`
 - **Pacman Users**: `pacman -S aichat`
 - **Windows Scoop Users:** `scoop install aichat`
+- **Windows WinGet Users:** `winget install --exact --id sigoden.AIChat`
 - **Android Termux Users:** `pkg install aichat`
 
 ### Pre-built Binaries
@@ -36,6 +38,8 @@ Explore powerful command-line functionalities with AIChat's CMD mode.
 
 Experience an interactive Chat-REPL with features like tab autocompletion, multi-line input support, history search, configurable keybindings, and custom REPL prompts.
 
+Editor commands from the `editor` configuration, `VISUAL`, or `EDITOR` may include arguments. They use POSIX shell-word quoting on every platform, so executable paths containing spaces must be quoted, for example `"C:\Program Files\Helix\hx.exe" --wait`.
+
 ![aichat-repl](https://github.com/user-attachments/assets/218fab08-cdae-4c3b-bcf8-39b6651f1362)
 
 ### Shell Assistant
@@ -54,6 +58,7 @@ Accept diverse input forms such as stdin, local files and directories, and remot
 | STDIN             | `cat data.txt \| aichat`             |                                  |
 | Last Reply        |                                      | `.file %%`                       |
 | Local files       | `aichat -f image.png -f data.txt`    | `.file image.png data.txt`       |
+| Shell-expanded files | `aichat --files src/*.rs -- explain` | `.file src/a.rs src/b.rs -- explain` |
 | Local directories | `aichat -f dir/`                     | `.file dir/`                     |
 | Remote URLs       | `aichat -f https://example.com`      | `.file https://example.com`      |
 | External commands | ```aichat -f '`git diff`'```         | ```.file `git diff` ```          |
@@ -105,6 +110,38 @@ AI Agent = Instructions (Prompt) + Tools (Function Callings) + Documents (RAG).
 
 ![aichat-agent](https://github.com/user-attachments/assets/0b7e687d-e642-4e8a-b1c1-d2d9b2da2b6b)
 
+A minimal local agent requires an agent definition and an entry in `agents.txt` under the functions directory. The agent-specific `config.yaml` is optional and only overrides runtime configuration such as the model, temperature, or default variables.
+
+```text
+<aichat-config-dir>/
+  functions/
+    agents.txt                  # contains: my-agent
+    agents/
+      my-agent/
+        index.yaml              # required agent definition
+        functions.json          # optional tools
+  agents/
+    my-agent/
+      config.yaml               # optional agent-specific config
+```
+
+Example `functions/agents.txt`:
+
+```text
+my-agent
+```
+
+Example `functions/agents/my-agent/index.yaml`:
+
+```yaml
+name: my-agent
+description: Helps with local project tasks.
+instructions: |
+  You are a concise assistant for this project.
+```
+
+After creating these files, run `aichat --list-agents` to confirm that the agent is discoverable, then use it with `aichat -a my-agent`.
+
 ### Local Server Capabilities
 
 AIChat includes a lightweight built-in HTTP server for easy deployment.
@@ -169,4 +206,4 @@ Copyright (c) 2023-2025 aichat-developers.
 
 AIChat is made available under the terms of either the MIT License or the Apache License 2.0, at your option.
 
-See the LICENSE-APACHE and LICENSE-MIT files for license details.
+See the LICENSE-APACHE and LICENSE-MIT files for license details.

src/cli.rs

@@ -51,6 +51,14 @@ pub struct Cli {
     /// Include files, directories, or URLs
     #[clap(short = 'f', long, value_name = "FILE")]
     pub file: Vec<String>,
+    /// Include multiple shell-expanded files; terminate the list with `--`
+    #[clap(
+        long = "files",
+        value_name = "FILE",
+        num_args = 1..,
+        value_terminator = "--"
+    )]
+    expanded_files: Vec<String>,
     /// Turn off stream mode
     #[clap(short = 'S', long)]
     pub no_stream: bool,
@@ -87,19 +95,35 @@ pub struct Cli {
 }
 
 impl Cli {
+    pub fn files(&self) -> Vec<String> {
+        self.file
+            .iter()
+            .chain(&self.expanded_files)
+            .cloned()
+            .collect()
+    }
+
+    pub fn has_files(&self) -> bool {
+        !self.file.is_empty() || !self.expanded_files.is_empty()
+    }
+
     pub fn text(&self) -> Result<Option<String>> {
         let mut stdin_text = String::new();
         if !stdin().is_terminal() {
             let _ = stdin()
                 .read_to_string(&mut stdin_text)
                 .context("Invalid stdin pipe")?;
         };
+        Ok(self.text_with_stdin(&stdin_text))
+    }
+
+    fn text_with_stdin(&self, stdin_text: &str) -> Option<String> {
         match self.text.is_empty() {
             true => {
                 if stdin_text.is_empty() {
-                    Ok(None)
+                    None
                 } else {
-                    Ok(Some(stdin_text))
+                    Some(stdin_text.to_string())
                 }
             }
             false => {
@@ -111,19 +135,108 @@ impl Cli {
                         .collect::<Vec<_>>()
                         .join(" ");
                     if stdin_text.is_empty() {
-                        Ok(Some(text))
+                        Some(text)
                     } else {
-                        Ok(Some(format!("{text} -- {stdin_text}")))
+                        Some(format!("{text} -- {stdin_text}"))
                     }
                 } else {
                     let text = self.text.join(" ");
                     if stdin_text.is_empty() {
-                        Ok(Some(text))
+                        Some(text)
                     } else {
-                        Ok(Some(format!("{text}\n{stdin_text}")))
+                        Some(format!("{text}\n{stdin_text}"))
                     }
                 }
             }
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parse(args: &[&str]) -> Cli {
+        Cli::try_parse_from(args).unwrap()
+    }
+
+    #[test]
+    fn preserves_single_and_repeated_file_options() {
+        let cli = parse(&["aichat", "-f", "one.md", "explain"]);
+        assert_eq!(cli.files(), ["one.md"]);
+        assert_eq!(cli.text_with_stdin(""), Some("explain".into()));
+
+        let cli = parse(&["aichat", "-f", "one.md", "--file", "two.md", "compare"]);
+        assert_eq!(cli.files(), ["one.md", "two.md"]);
+        assert_eq!(cli.text_with_stdin(""), Some("compare".into()));
+    }
+
+    #[test]
+    fn parses_explicit_shell_expanded_file_list() {
+        let cli = parse(&[
+            "aichat", "--files", "src/a.rs", "src/b.rs", "--", "review", "these",
+        ]);
+        assert_eq!(cli.files(), ["src/a.rs", "src/b.rs"]);
+        assert_eq!(cli.text_with_stdin(""), Some("review these".into()));
+    }
+
+    #[test]
+    fn preserves_literal_file_values_without_inference() {
+        let cli = parse(&[
+            "aichat",
+            "--files",
+            "src/*.rs",
+            "docs/",
+            "https://example.com/context",
+            "%%",
+            "file with spaces.md",
+            "--",
+            "summarize",
+        ]);
+        assert_eq!(
+            cli.files(),
+            [
+                "src/*.rs",
+                "docs/",
+                "https://example.com/context",
+                "%%",
+                "file with spaces.md",
+            ]
+        );
+        assert_eq!(cli.text_with_stdin(""), Some("summarize".into()));
+    }
+
+    #[test]
+    fn does_not_reclassify_prompt_tokens_as_files() {
+        let cli = parse(&["aichat", "-f", "context.md", "README.md", "explain"]);
+        assert_eq!(cli.files(), ["context.md"]);
+        assert_eq!(cli.text_with_stdin(""), Some("README.md explain".into()));
+    }
+
+    #[test]
+    fn combines_explicit_files_with_stdin_and_command_modes() {
+        let cli = parse(&[
+            "aichat",
+            "--execute",
+            "--files",
+            "script one.sh",
+            "script-two.sh",
+            "--",
+            "inspect",
+        ]);
+        assert!(cli.execute);
+        assert!(cli.has_files());
+        assert_eq!(cli.text_with_stdin("piped"), Some("inspect\npiped".into()));
+
+        let cli = parse(&["aichat", "--code", "--files", "src/a.rs", "--", "rewrite"]);
+        assert!(cli.code);
+        assert_eq!(cli.files(), ["src/a.rs"]);
+    }
+
+    #[test]
+    fn accepts_stdin_without_prompt_text() {
+        let cli = parse(&["aichat"]);
+        assert_eq!(cli.text_with_stdin("from stdin"), Some("from stdin".into()));
+        assert_eq!(cli.text_with_stdin(""), None);
+    }
+}

src/config/input.rs

@@ -9,7 +9,7 @@ use crate::utils::{base64_encode, is_loader_protocol, sha256, AbortSignal};
 
 use anyhow::{bail, Context, Result};
 use indexmap::IndexSet;
-use std::{collections::HashMap, fs::File, io::Read};
+use std::collections::HashMap;
 use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
 
 const IMAGE_EXTS: [&str; 5] = ["png", "jpeg", "jpg", "webp", "gif"];
@@ -574,6 +574,7 @@ async fn load_documents(
     for file_path in local_files {
         if is_image(&file_path) {
             let contents = read_media_to_data_url(&file_path)
+                .await
                 .with_context(|| format!("Unable to read media '{file_path}'"))?;
             data_urls.insert(sha256(&contents), file_path);
             medias.push(contents)
@@ -628,21 +629,51 @@ fn is_image(path: &str) -> bool {
         .unwrap_or_default()
 }
 
-fn read_media_to_data_url(image_path: &str) -> Result<String> {
+async fn read_media_to_data_url(image_path: &str) -> Result<String> {
+    let buffer = tokio::fs::read(image_path)
+        .await
+        .with_context(|| format!("Failed to read media bytes from '{image_path}'"))?;
+    media_bytes_to_data_url(image_path, &buffer)
+}
+
+fn media_bytes_to_data_url(image_path: &str, buffer: &[u8]) -> Result<String> {
     let extension = get_patch_extension(image_path).unwrap_or_default();
     let mime_type = match extension.as_str() {
         "png" => "image/png",
         "jpg" | "jpeg" => "image/jpeg",
         "webp" => "image/webp",
         "gif" => "image/gif",
-        _ => bail!("Unexpected media type"),
+        _ => bail!("Unexpected media type for '{image_path}'"),
     };
-    let mut file = File::open(image_path)?;
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer)?;
 
     let encoded_image = base64_encode(buffer);
     let data_url = format!("data:{mime_type};base64,{encoded_image}");
 
     Ok(data_url)
 }
+
+#[cfg(test)]
+mod media_tests {
+    use super::*;
+
+    #[test]
+    fn media_bytes_keep_the_existing_data_url_format() {
+        let data_url = media_bytes_to_data_url("sample.png", &[0, 1, 2, 255]).unwrap();
+        assert_eq!(data_url, "data:image/png;base64,AAEC/w==");
+    }
+
+    #[test]
+    fn unsupported_media_error_includes_the_path() {
+        let error = media_bytes_to_data_url("sample.bmp", &[1, 2, 3]).unwrap_err();
+        assert_eq!(error.to_string(), "Unexpected media type for 'sample.bmp'");
+    }
+
+    #[tokio::test]
+    async fn async_media_read_error_includes_the_path() {
+        let path =
+            std::env::temp_dir().join(format!("aichat-missing-media-{}.png", std::process::id()));
+        let path = path.to_string_lossy();
+        let error = read_media_to_data_url(&path).await.unwrap_err();
+        assert!(error.to_string().contains(path.as_ref()));
+    }
+}