v0.2.13 : prompt avec emojis colores — 🗂️ repertoire, 🤖 catalogue, 🌐 externes, 📊 geres, ⚡ duree de la derniere commande, ⏲ session

Cargo.lock

@@ -21,7 +21,7 @@ dependencies = [
 
 [[package]]
 name = "agent-manager"
-version = "0.2.10"
+version = "0.2.13"
 dependencies = [
  "anyhow",
  "chrono",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "agent-manager"
-version = "0.2.10"
+version = "0.2.13"
 edition = "2021"
 description = "Manage local AI coding agents: list, install, start, stop, update — with automatic dependency handling and a YAML-driven catalog."
 license = "MIT"

src/nav.rs

@@ -51,9 +51,8 @@ pub fn dir_size(path: &Path) -> Option<u64> {
     Some(total)
 }
 
-fn modified_str(path: &Path) -> String {
-    std::fs::metadata(path)
-        .and_then(|m| m.modified())
+fn modified_text(meta: &std::fs::Metadata) -> String {
+    meta.modified()
         .ok()
         .map(|t| {
             let dt: chrono::DateTime<chrono::Local> = t.into();
@@ -94,59 +93,86 @@ fn is_executable(path: &Path, meta: &std::fs::Metadata) -> bool {
     }
 }
 
+/// One ls row: (sort key, cells). A single symlink_metadata call per entry
+/// (the modification time comes from the same metadata).
+fn row_for(p: &Path, color: bool) -> Option<(String, Vec<Cell>)> {
+    let meta = std::fs::symlink_metadata(p).ok()?;
+    let file_type = meta.file_type();
+    let name = p.file_name().and_then(|n| n.to_str())?.to_string();
+    let (kind, style) = if file_type.is_symlink() {
+        ("symlink", if p.exists() { 3 } else { 4 })
+    } else if file_type.is_dir() {
+        ("dir", 1)
+    } else if is_executable(p, &meta) {
+        ("file", 2)
+    } else {
+        ("file", 0)
+    };
+    let (size_text, size_bytes) = if file_type.is_dir() {
+        match dir_size(p) {
+            Some(s) => (format_size(s), Some(s)),
+            None => ("—".to_string(), None),
+        }
+    } else {
+        (format_size(meta.len()), Some(meta.len()))
+    };
+    let mut display = name.clone();
+    if file_type.is_dir() {
+        display.push('/');
+    } else if file_type.is_symlink() {
+        if let Ok(target) = std::fs::read_link(p) {
+            display.push_str(&format!(" -> {}", target.display()));
+        }
+    }
+    Some((
+        name.to_lowercase(),
+        vec![
+            Cell::str(paint(&display, color, style)),
+            Cell::str(kind.to_string()),
+            Cell::bytes(size_bytes.unwrap_or(0), size_text),
+            Cell::str(modified_text(&meta)),
+        ],
+    ))
+}
+
 /// Build the ls table (columns: name, type, size, modified). Directories
 /// come first, then alphabetical order.
+///
+/// Rows are built in parallel: recursive directory sizes dominate the cost,
+/// so a listing with many subdirectories stays fast (like Nushell, which
+/// also parallelizes its listing).
 pub fn ls_table(path: &Path, color: bool) -> Result<DataTable> {
     let rd = std::fs::read_dir(path)
         .with_context(|| format!("cannot read {}", path.display()))?;
-    let mut rows: Vec<(String, Vec<Cell>)> = Vec::new();
-    for entry in rd.flatten() {
-        let p = entry.path();
-        let meta = match std::fs::symlink_metadata(&p) {
-            Ok(m) => m,
-            Err(_) => continue,
-        };
-        let file_type = meta.file_type();
-        let name = p
-            .file_name()
-            .map(|n| n.to_string_lossy().to_string())
-            .unwrap_or_default();
-        let (kind, style) = if file_type.is_symlink() {
-            ("symlink", if p.exists() { 3 } else { 4 })
-        } else if file_type.is_dir() {
-            ("dir", 1)
-        } else if is_executable(&p, &meta) {
-            ("file", 2)
-        } else {
-            ("file", 0)
-        };
-        let (size_text, size_bytes) = if file_type.is_dir() {
-            match dir_size(&p) {
-                Some(s) => (format_size(s), Some(s)),
-                None => ("—".to_string(), None),
-            }
-        } else {
-            (format_size(meta.len()), Some(meta.len()))
-        };
-        let mut display = name.clone();
-        if file_type.is_dir() {
-            display.push('/');
-        } else if file_type.is_symlink() {
-            if let Ok(target) = std::fs::read_link(&p) {
-                display.push_str(&format!(" -> {}", target.display()));
+    let entries: Vec<PathBuf> = rd.flatten().map(|e| e.path()).collect();
+
+    let threads = std::thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(4)
+        .min(8);
+    let chunk_size = entries.len().div_ceil(threads).max(1);
+    let rows: Vec<(String, Vec<Cell>)> = std::thread::scope(|scope| {
+        let mut handles = Vec::new();
+        for chunk in entries.chunks(chunk_size) {
+            let chunk: Vec<PathBuf> = chunk.to_vec();
+            handles.push(scope.spawn(move || {
+                chunk
+                    .into_iter()
+                    .filter_map(|p| row_for(&p, color))
+                    .collect::<Vec<_>>()
+            }));
+        }
+        let mut out = Vec::new();
+        for handle in handles {
+            if let Ok(mut rows) = handle.join() {
+                out.append(&mut rows);
             }
         }
-        rows.push((
-            name.to_lowercase(),
-            vec![
-                Cell::str(paint(&display, color, style)),
-                Cell::str(kind.to_string()),
-                Cell::bytes(size_bytes.unwrap_or(0), size_text),
-                Cell::str(modified_str(&p)),
-            ],
-        ));
-    }
+        out
+    });
+
     // Directories first, then alphabetical.
+    let mut rows = rows;
     rows.sort_by(|a, b| {
         let a_dir = a.1[1].text == "dir";
         let b_dir = b.1[1].text == "dir";

src/repl.rs

@@ -354,6 +354,7 @@ pub fn banner_box(
     version: &str,
     agents: usize,
     installed: usize,
+    external: usize,
     session: &ShellSession,
     session_id: &str,
     cwd: &str,
@@ -425,7 +426,7 @@ pub fn banner_box(
     rows.push(blank());
     rows.push(inner(dim(
         &format!(
-            "am v{version} · {agents} agents · {installed} installed · shell {} · /help for commands",
+            "am v{version} · {agents} agents · {external} external · {installed} managed · shell {} · /help for commands",
             session.current.name
         ),
         color,
@@ -449,6 +450,7 @@ pub fn banner(app: &App, session: &ShellSession, session_id: &str) -> String {
         env!("CARGO_PKG_VERSION"),
         agent_count(app),
         installed_count(app),
+        external_count(app),
         session,
         session_id,
         &current_dir_string(),
@@ -472,27 +474,50 @@ pub fn banner(app: &App, session: &ShellSession, session_id: &str) -> String {
     text
 }
 
-/// One-line status shown before every prompt (Hermes-style status bar).
-fn print_status(app: &App, session: &ShellSession, started: Instant) {
+/// Color an emoji glyph (style names: green, blue, yellow, cyan).
+fn emoji(glyph: &str, style: &str, color: bool) -> String {
+    if !color {
+        return glyph.to_string();
+    }
+    match style {
+        "green" => glyph.green().to_string(),
+        "blue" => glyph.blue().to_string(),
+        "yellow" => glyph.yellow().to_string(),
+        "cyan" => glyph.cyan().to_string(),
+        _ => glyph.to_string(),
+    }
+}
+
+/// One-line status shown before every prompt, with colored emojis:
+///  ⚙ am v0.2.13 │ 🗂️ cwd │ 73 🤖 · 12 🌐 · 0 📊 │ ⚡ 97ms │ ⏲ 32s
+/// The last parameter is the duration of the previous command (None before
+/// the first one).
+fn print_status(app: &App, started: Instant, last: Option<Duration>) {
     let color = app.color();
     let sep = dim(" │ ", color);
-    let cwd = shorten_head(&current_dir_string(), 26);
-    let shell_part = format!(
-        "{} {}",
-        bold_cyan(session.current.name, color),
-        dim(&cwd, color)
+    let cwd = shorten_head(&current_dir_string(), 30);
+    let folder = format!("{} {}", emoji("🗂️", "cyan", color), dim(&cwd, color));
+    let counts = format!(
+        "{} {} {} {} {} {} {} {}",
+        dim(&agent_count(app).to_string(), color),
+        emoji("🤖", "green", color),
+        dim("·", color),
+        dim(&external_count(app).to_string(), color),
+        emoji("🌐", "blue", color),
+        dim("·", color),
+        dim(&installed_count(app).to_string(), color),
+        emoji("📊", "yellow", color),
     );
-    let counts = dim(
-        &format!(
-            "{} agents · {} installed",
-            agent_count(app),
-            installed_count(app)
-        ),
-        color,
-    );
-    let elapsed = dim(&format_elapsed(started.elapsed()), color);
+    let last_text = match last {
+        Some(d) if d.as_secs() >= 1 => format_elapsed(d),
+        Some(d) if d.as_millis() >= 1 => format!("{}ms", d.as_millis()),
+        Some(d) => format!("{}µs", d.as_micros()),
+        None => "—".to_string(),
+    };
+    let last_part = format!("{} {}", emoji("⚡", "yellow", color), dim(&last_text, color));
+    let elapsed = dim(&format!("⏲ {}", format_elapsed(started.elapsed())), color);
     println!(
-        "{}am v{}{sep}{shell_part}{sep}{counts}{sep}⏲ {elapsed}",
+        "{}am v{}{sep}{folder}{sep}{counts}{sep}{last_part}{sep}{elapsed}",
         dim(" ⚙ ", color),
         env!("CARGO_PKG_VERSION"),
     );
@@ -609,6 +634,25 @@ fn installed_count(app: &App) -> usize {
         .unwrap_or(0)
 }
 
+/// Number of external agents (installed outside agent-manager) detected on
+/// the PATH — the same definition used by the "external" status in am list.
+fn external_count(app: &App) -> usize {
+    let probe = crate::probe::detect_externals(app);
+    let managed: std::collections::BTreeSet<String> = app
+        .state
+        .load()
+        .ok()
+        .map(|s| s.installed.keys().cloned().collect())
+        .unwrap_or_default();
+    app.catalog
+        .agents()
+        .iter()
+        .filter(|a| !a.hidden && a.installable)
+        .filter(|a| !managed.contains(&a.name))
+        .filter(|a| probe.path_of(&a.name).is_some())
+        .count()
+}
+
 fn current_dir_string() -> String {
     std::env::current_dir()
         .map(|p| p.display().to_string())
@@ -672,8 +716,9 @@ fn run_with_editor(app: &App, session: &mut ShellSession) -> Result<i32> {
     }
     let started = Instant::now();
     let mut last: Option<DataTable> = None;
+    let mut last_duration: Option<Duration> = None;
     loop {
-        print_status(app, session, started);
+        print_status(app, started, last_duration);
         match rl.readline("❯ ") {
             Ok(line) => {
                 let trimmed = line.trim().to_string();
@@ -681,7 +726,10 @@ fn run_with_editor(app: &App, session: &mut ShellSession) -> Result<i32> {
                     continue;
                 }
                 let _ = rl.add_history_entry(trimmed.as_str());
-                match handle_input(app, session, &mut last, &trimmed) {
+                let t = Instant::now();
+                let result = handle_input(app, session, &mut last, &trimmed);
+                last_duration = Some(t.elapsed());
+                match result {
                     Ok(true) => break,
                     Ok(false) => {}
                     Err(e) => app.log.error(&format!("{e:#}")),
@@ -703,8 +751,9 @@ fn run_with_editor(app: &App, session: &mut ShellSession) -> Result<i32> {
 fn run_plain(app: &App, session: &mut ShellSession) -> Result<i32> {
     let started = Instant::now();
     let mut last: Option<DataTable> = None;
+    let mut last_duration: Option<Duration> = None;
     loop {
-        print_status(app, session, started);
+        print_status(app, started, last_duration);
         eprint!("❯ ");
         std::io::stderr().flush().ok();
         let mut line = String::new();
@@ -715,7 +764,10 @@ fn run_plain(app: &App, session: &mut ShellSession) -> Result<i32> {
         if line.is_empty() {
             continue;
         }
-        match handle_input(app, session, &mut last, &line) {
+        let t = Instant::now();
+        let result = handle_input(app, session, &mut last, &line);
+        last_duration = Some(t.elapsed());
+        match result {
             Ok(true) => break,
             Ok(false) => {}
             Err(e) => app.log.error(&format!("{e:#}")),
@@ -1245,6 +1297,7 @@ mod tests {
             "9.9.9",
             65,
             3,
+            12,
             &session,
             "20260815_123456_abcdef",
             "/home/alice/dev/agent-manager",
@@ -1258,6 +1311,8 @@ mod tests {
         assert!(text.contains("(default)"));
         assert!(text.contains("bash"));
         assert!(text.contains("/help for commands"));
+        assert!(text.contains("12 external"));
+        assert!(text.contains("3 managed"));
         assert!(text.contains("agent-manager"));
     }