Merge pull request #106 from 7df-lab/dev/deep_research_0614

Add /research command for deep research

Author: wangtsiao

Cargo.lock

@@ -17,6 +17,7 @@
 //! }
 //! ```
 
+use std::ffi::OsString;
 use std::future::Future;
 use std::io::ErrorKind;
 use std::path::Path;
@@ -27,6 +28,7 @@ use anyhow::Result;
 
 /// Alias name for the server sub‑binary.
 const SERVER_ALIAS: &str = "devo-server";
+const ALIAS_SENTINEL_PREFIX: &str = "--devo-alias=";
 
 /// Directory (under DEVO_HOME/tmp/arg0) where alias entries are created.
 const ALIAS_TEMP_ROOT: &str = "arg0";
@@ -111,7 +113,15 @@ where
 /// Returns the alias name if the process was invoked through one of our
 /// symlinks or batch scripts, or `None` for a normal `devo` invocation.
 fn argv0_alias() -> Option<&'static str> {
-    let argv0 = std::env::args_os().next().unwrap_or_default();
+    argv0_alias_from_args(std::env::args_os())
+}
+
+fn argv0_alias_from_args<I>(args: I) -> Option<&'static str>
+where
+    I: IntoIterator<Item = OsString>,
+{
+    let mut args = args.into_iter();
+    let argv0 = args.next().unwrap_or_default();
     let file_name = Path::new(&argv0)
         .file_stem()
         .and_then(|s| s.to_str())
@@ -123,19 +133,39 @@ fn argv0_alias() -> Option<&'static str> {
     }
 
     // Windows batch scripts pass the intended alias via a sentinel arg.
-    let mut args = std::env::args_os();
-    args.next(); // skip argv[0]
-    if let Some(sentinel) = args.next()
-        && let Some(s) = sentinel.to_str()
-        && let Some(rest) = s.strip_prefix("--devo-alias=")
-        && rest == SERVER_ALIAS
-    {
+    if args.next().as_deref().is_some_and(is_server_alias_sentinel) {
         return Some(SERVER_ALIAS);
     }
 
     None
 }
 
+fn is_server_alias_sentinel(arg: &std::ffi::OsStr) -> bool {
+    arg.to_str()
+        .and_then(|s| s.strip_prefix(ALIAS_SENTINEL_PREFIX))
+        .is_some_and(|rest| rest == SERVER_ALIAS)
+}
+
+fn server_dispatch_args() -> Vec<OsString> {
+    server_dispatch_args_from(std::env::args_os())
+}
+
+fn server_dispatch_args_from<I>(args: I) -> Vec<OsString>
+where
+    I: IntoIterator<Item = OsString>,
+{
+    let mut args = args.into_iter();
+    let mut filtered = vec![args.next().unwrap_or_else(|| OsString::from(SERVER_ALIAS))];
+
+    if let Some(first_arg) = args.next()
+        && !is_server_alias_sentinel(&first_arg)
+    {
+        filtered.push(first_arg);
+    }
+    filtered.extend(args);
+    filtered
+}
+
 /// Build a multi‑thread Tokio runtime.
 fn build_runtime() -> Result<tokio::runtime::Runtime> {
     let mut builder = tokio::runtime::Builder::new_multi_thread();
@@ -150,7 +180,7 @@ fn build_runtime() -> Result<tokio::runtime::Runtime> {
 /// consumed by `argv0_alias()` so the remaining args are the server's own.
 async fn run_server_dispatch() {
     use clap::Parser;
-    let args = devo_server::ServerProcessArgs::parse();
+    let args = devo_server::ServerProcessArgs::parse_from(server_dispatch_args());
     let home_dir = match devo_util_paths::find_devo_home() {
         Ok(d) => d,
         Err(err) => {
@@ -208,7 +238,13 @@ where
     I: IntoIterator<Item = std::result::Result<(String, String), dotenvy::Error>>,
 {
     for (key, value) in iter.into_iter().flatten() {
-        if !key.to_ascii_uppercase().starts_with(ILLEGAL_ENV_VAR_PREFIX) {
+        // Avoid allocating an uppercased copy for every dotenv key; the
+        // reserved prefix is ASCII, so byte-wise case folding is equivalent.
+        let has_illegal_prefix = key
+            .as_bytes()
+            .get(..ILLEGAL_ENV_VAR_PREFIX.len())
+            .is_some_and(|prefix| prefix.eq_ignore_ascii_case(ILLEGAL_ENV_VAR_PREFIX.as_bytes()));
+        if !has_illegal_prefix {
             // SAFETY: called before any threads are spawned.
             unsafe { std::env::set_var(&key, &value) };
         }
@@ -384,6 +420,7 @@ struct PathGuard {
 
 #[cfg(test)]
 mod tests {
+    use std::ffi::OsString;
     use std::fs;
     use std::io::ErrorKind;
     use std::path::Path;
@@ -409,6 +446,58 @@ mod tests {
         assert_eq!(super::argv0_alias(), None);
     }
 
+    #[test]
+    fn argv0_alias_detects_batch_sentinel() {
+        let args = vec![
+            OsString::from("devo.exe"),
+            OsString::from("--devo-alias=devo-server"),
+            OsString::from("--transport"),
+            OsString::from("stdio"),
+        ];
+
+        assert_eq!(
+            super::argv0_alias_from_args(args),
+            Some(super::SERVER_ALIAS)
+        );
+    }
+
+    #[test]
+    fn server_dispatch_args_remove_batch_alias_sentinel() {
+        let args = vec![
+            OsString::from("devo.exe"),
+            OsString::from("--devo-alias=devo-server"),
+            OsString::from("--transport"),
+            OsString::from("stdio"),
+        ];
+
+        assert_eq!(
+            super::server_dispatch_args_from(args),
+            vec![
+                OsString::from("devo.exe"),
+                OsString::from("--transport"),
+                OsString::from("stdio")
+            ]
+        );
+    }
+
+    #[test]
+    fn server_dispatch_args_keep_direct_alias_args() {
+        let args = vec![
+            OsString::from("devo-server"),
+            OsString::from("--transport"),
+            OsString::from("stdio"),
+        ];
+
+        assert_eq!(
+            super::server_dispatch_args_from(args),
+            vec![
+                OsString::from("devo-server"),
+                OsString::from("--transport"),
+                OsString::from("stdio")
+            ]
+        );
+    }
+
     #[test]
     fn lock_unavailable_detection_handles_would_block() {
         assert_eq!(

crates/arg0/src/lib.rs

@@ -1,3 +1,9 @@
+//! `devo doctor` health checks for local configuration and provider readiness.
+//!
+//! This command is intentionally diagnostic rather than mutating: it reports
+//! toolchain, config, provider-resolution, and model-catalog state so users can
+//! fix setup issues before launching the interactive runtime.
+
 use anyhow::Result;
 use devo_core::AppConfigLoader;
 use devo_core::FileSystemAppConfigLoader;
@@ -16,8 +22,8 @@ pub(crate) async fn run_doctor() -> Result<()> {
     let rustc = Command::new("rustc").arg("--version").output();
     match rustc {
         Ok(output) => {
-            let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
-            println!("  {}", version);
+            let version = String::from_utf8_lossy(&output.stdout);
+            println!("  {}", version.trim());
         }
         Err(e) => {
             println!("  {} rustc not found: {}", "✗".red(), e);
@@ -78,7 +84,7 @@ pub(crate) async fn run_doctor() -> Result<()> {
                     println!("  model:      {}", resolved.model);
                     println!(
                         "  base_url:   {}",
-                        resolved.base_url.unwrap_or("default".into())
+                        resolved.base_url.as_deref().unwrap_or("default")
                     );
                     println!("  wire_api:   {:?}", resolved.wire_api);
                     if resolved.api_key.is_some() {

crates/cli/src/doctor_command.rs

@@ -1,3 +1,11 @@
+//! User-facing CLI entrypoint for interactive, prompt, diagnostic, upgrade,
+//! and hidden server process modes.
+//!
+//! This binary owns command-line parsing, startup update checks, logging
+//! bootstrap, and final exit messages. Long-lived runtime behavior is delegated
+//! to the server, TUI, and core crates so CLI changes stay focused on process
+//! orchestration and display.
+
 use anyhow::Result;
 use clap::Parser;
 use clap::Subcommand;
@@ -62,14 +70,16 @@ fn main() -> Result<()> {
 
 fn format_with_separators(value: usize) -> String {
     let digits = value.to_string();
-    let mut out = String::new();
-    for (index, ch) in digits.chars().rev().enumerate() {
-        if index > 0 && index % 3 == 0 {
+    let separator_count = digits.len().saturating_sub(1) / 3;
+    let first_group_len = digits.len() - separator_count * 3;
+    let mut out = String::with_capacity(digits.len() + separator_count);
+    for (index, ch) in digits.chars().enumerate() {
+        if index > 0 && index >= first_group_len && (index - first_group_len).is_multiple_of(3) {
             out.push(',');
         }
         out.push(ch);
     }
-    out.chars().rev().collect()
+    out
 }
 
 fn format_token_usage_line(exit: &devo_tui::AppExit, color_enabled: bool) -> Option<String> {
@@ -86,11 +96,7 @@ fn format_token_usage_line(exit: &devo_tui::AppExit, color_enabled: bool) -> Opt
     let cached_suffix = if exit.total_cache_read_tokens > 0 {
         let cached_value = format_with_separators(exit.total_cache_read_tokens);
         if color_enabled {
-            format!(
-                " (+ {} {})",
-                "\u{1b}[1;33m".to_string() + &cached_value + "\u{1b}[0m",
-                "\u{1b}[33mcached\u{1b}[0m"
-            )
+            format!(" (+ \u{1b}[1;33m{cached_value}\u{1b}[0m \u{1b}[33mcached\u{1b}[0m)")
         } else {
             format!(" (+ {cached_value} cached)")
         }
@@ -131,9 +137,9 @@ fn exit_messages(exit: &devo_tui::AppExit, color_enabled: bool) -> Vec<String> {
             command
         };
         let prefix = if color_enabled {
-            "\u{1b}[2mTo continue this session, run\u{1b}[0m".to_string()
+            "\u{1b}[2mTo continue this session, run\u{1b}[0m"
         } else {
-            "To continue this session, run".to_string()
+            "To continue this session, run"
         };
         lines.push(format!("{prefix} {command}"));
     }