Quality: shared pluralize helper for log/error/UI strings

Hand-rolled `format!("{n} files")` reads as `1 files` when `n == 1`. New `pluralize(n, "file")` returns `"1 file"` / `"3 files"`; pass an explicit plural for irregulars (`pluralize_with(n, "entry", "entries")` in Rust, `pluralize(n, 'entry', 'entries')` in TS).

- New `apps/desktop/src-tauri/src/pluralize.rs` (generic over `usize`/`u32`/`u64`/…).
- New `apps/desktop/src/lib/utils/pluralize.ts` with the third arg optional (defaults to `+s`).
- Old `column_meta::pluralize` and `selection-info-utils::pluralize` re-export from the new locations.
- Swept ~50 real sites across indexing, search, MCP, AI, viewer, transfer dialogs, license dialog, error-report dialog, etc. User-facing strings (license dialog, error-report sample headings, debug toast count) included.

New `pluralize-noun` check (`scripts/check/checks/pluralize-noun.go`) catches new `{var} <plural>` patterns in Rust + TS/Svelte. Filters comments, structured `key=value` log shapes, non-plural English words (`was`, `is`, `exceeds`, …), Svelte attribute bindings, and the git `stash@{n}` shorthand. Opt-out via `// allowed-pluralize-noun: <reason>`. Runs in ~0.3 s.

Author: vdavid

apps/desktop/src-tauri/src/ai/api_keys.rs

@@ -4,6 +4,7 @@
 //! key sits in the OS-native secret backend (macOS Keychain, Linux Secret Service, etc.) instead
 //! of `settings.json`. One entry per provider keyed as `ai.apiKey.<providerId>`.
 
+use crate::pluralize::pluralize;
 use crate::secrets::SecretStoreError;
 use log::{debug, info};
 use serde::{Deserialize, Serialize};
@@ -51,7 +52,10 @@ pub fn save(provider_id: &str, api_key: &str) -> Result<(), AiApiKeyError> {
     let key = store_key(provider_id);
     let key_len = api_key.len();
     crate::secrets::store().set(&key, api_key.as_bytes())?;
-    info!("AI API key saved for provider {provider_id} ({key_len} bytes)");
+    info!(
+        "AI API key saved for provider {provider_id} ({})",
+        pluralize(key_len, "byte")
+    );
     Ok(())
 }
 

apps/desktop/src-tauri/src/ai/client_local_llama_test.rs

@@ -69,7 +69,7 @@ async fn local_streaming_emits_multiple_chunks_progressively() {
         .await
         .expect("stream should open against local server");
 
-    let mut chunks = 0;
+    let mut chunks: usize = 0;
     let mut total = String::new();
     let mut first_chunk_at = None;
     while let Some(item) = stream.next().await {
@@ -95,7 +95,8 @@ async fn local_streaming_emits_multiple_chunks_progressively() {
 
     log::info!(
         target: "ai_smoke",
-        "local stream → {chunks} chunks, ttft={ttft:?}, total={total_elapsed:?}, content: {total}"
+        "local stream → {}, ttft={ttft:?}, total={total_elapsed:?}, content: {total}",
+        crate::pluralize::pluralize(chunks, "chunk")
     );
 }
 

apps/desktop/src-tauri/src/ai/client_real_anthropic_test.rs

@@ -75,7 +75,7 @@ async fn smoke_claude_haiku_stream() {
     .expect("stream open");
 
     let mut text = String::new();
-    let mut chunks = 0;
+    let mut chunks: usize = 0;
     while let Some(item) = stream.next().await {
         let chunk = item.expect("chunk ok");
         text.push_str(&chunk);
@@ -84,5 +84,9 @@ async fn smoke_claude_haiku_stream() {
 
     assert!(!text.trim().is_empty(), "expected non-empty assembled text");
     assert!(chunks > 0, "expected at least one chunk");
-    log::info!(target: "ai_smoke", "claude-3-5-haiku stream → {chunks} chunks, total: {text}");
+    log::info!(
+        target: "ai_smoke",
+        "claude-3-5-haiku stream → {}, total: {text}",
+        crate::pluralize::pluralize(chunks, "chunk")
+    );
 }

apps/desktop/src-tauri/src/ai/client_real_openai_test.rs

@@ -113,13 +113,17 @@ async fn collect_stream(backend: &AiBackend, model_label: &str) -> String {
     .await
     .expect("stream open");
     let mut text = String::new();
-    let mut chunks = 0;
+    let mut chunks: usize = 0;
     while let Some(item) = stream.next().await {
         let chunk = item.expect("chunk ok");
         text.push_str(&chunk);
         chunks += 1;
     }
-    log::info!(target: "ai_smoke", "{model_label} stream → {chunks} chunks, total: {text}");
+    log::info!(
+        target: "ai_smoke",
+        "{model_label} stream → {}, total: {text}",
+        crate::pluralize::pluralize(chunks, "chunk")
+    );
     text
 }
 

apps/desktop/src-tauri/src/ai/extract.rs

@@ -4,6 +4,8 @@ use std::fs;
 use std::path::Path;
 use tauri::{AppHandle, Manager, Runtime};
 
+use crate::pluralize::pluralize;
+
 /// Binary filename for the llama-server executable.
 pub const LLAMA_SERVER_BINARY: &str = "llama-server";
 
@@ -30,7 +32,7 @@ pub fn extract_bundled_llama_server<R: Runtime>(app: &AppHandle<R>, ai_dir: &Pat
 
     let entries = fs::read_dir(&resource_dir).map_err(|e| format!("Failed to read bundled AI directory: {e}"))?;
 
-    let mut copied_count = 0;
+    let mut copied_count: usize = 0;
     for entry in entries {
         let entry = entry.map_err(|e| format!("Failed to read directory entry: {e}"))?;
         let src_path = entry.path();
@@ -83,6 +85,6 @@ pub fn extract_bundled_llama_server<R: Runtime>(app: &AppHandle<R>, ai_dir: &Pat
         return Err(String::from("llama-server binary not found in bundled resources"));
     }
 
-    log::debug!("AI: copied {copied_count} files from bundled resources");
+    log::debug!("AI: copied {} from bundled resources", pluralize(copied_count, "file"));
     Ok(())
 }

apps/desktop/src-tauri/src/ai/manager.rs

@@ -13,6 +13,7 @@ use super::process::{
 };
 use super::{AiState, AiStatus, ModelInfo, get_default_model, get_model_by_id, is_local_ai_supported};
 use crate::ignore_poison::IgnorePoison;
+use crate::pluralize::pluralize;
 use std::collections::HashMap;
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -992,7 +993,10 @@ async fn wait_for_server_health(ai_dir: &Path, pid: u32, port: u16) -> Result<()
         if i % 10 == 9 {
             log::debug!("AI server: still waiting for health check ({}s)...", (i + 1) / 2);
             if let Some((line_count, last_line)) = log_diagnostics(ai_dir) {
-                log::debug!("AI server: log has {line_count} lines, last: {last_line}");
+                log::debug!(
+                    "AI server: log has {}, last: {last_line}",
+                    pluralize(line_count, "line")
+                );
             }
         }
     }

apps/desktop/src-tauri/src/commands/error_reporter.rs

@@ -6,6 +6,7 @@
 use crate::error_reporter::{
     self, BundleKind, BundleManifest, BundleScope, FLOW_A_BUNDLE_CAP_MB, settings_defaults::SettingValue,
 };
+use crate::pluralize::pluralize;
 use serde::Serialize;
 use std::collections::HashMap;
 
@@ -124,8 +125,9 @@ pub async fn save_error_report_to_disk(app: tauri::AppHandle, user_note: Option<
 fn validate_user_note(user_note: Option<String>) -> Result<Option<String>, String> {
     match user_note {
         Some(n) if n.chars().count() > MAX_USER_NOTE_CHARS => Err(format!(
-            "User note is too long ({} chars). Maximum is {MAX_USER_NOTE_CHARS} chars.",
-            n.chars().count(),
+            "User note is too long ({}). Maximum is {}.",
+            pluralize(n.chars().count(), "char"),
+            pluralize(MAX_USER_NOTE_CHARS, "char"),
         )),
         other => Ok(other),
     }

apps/desktop/src-tauri/src/commands/search.rs

@@ -18,6 +18,7 @@ use crate::search::{
 };
 
 use crate::indexing::writer::WRITER_GENERATION;
+use crate::pluralize::pluralize_with;
 use crate::search::ai::{self, query_builder as ai_query_builder};
 
 #[derive(Debug, Clone, Serialize, specta::Type)]
@@ -106,7 +107,10 @@ pub async fn prepare_search_index(app: tauri::AppHandle) -> Result<PrepareResult
                     backstop_timer: Some(backstop),
                     load_cancel: Some(cancel),
                 });
-                log::debug!("Search index ready: {entry_count} entries");
+                log::debug!(
+                    "Search index ready: {}",
+                    pluralize_with(entry_count, "entry", "entries")
+                );
                 // Emit event to frontend
                 use tauri::Emitter;
                 let _ = app_clone.emit(

apps/desktop/src-tauri/src/file_system/git/column_meta.rs

@@ -25,14 +25,7 @@ use gix::object::tree::EntryKind;
 use super::friendly::{FriendlyGitError, FriendlyGitErrorKind};
 use super::repo::{RepoHandle, count_ahead_behind};
 
-/// Pluralizes a noun based on count: `1 commit` / `12 commits`.
-pub fn pluralize(count: u64, singular: &str, plural: &str) -> String {
-    if count == 1 {
-        format!("1 {}", singular)
-    } else {
-        format!("{} {}", count, plural)
-    }
-}
+pub use crate::pluralize::{pluralize, pluralize_with};
 
 /// Picks a fallback comparison branch for ahead/behind when the branch has
 /// no configured upstream. Tries `main`, then `master`. Returns the
@@ -311,9 +304,9 @@ mod tests {
 
     #[test]
     fn pluralize_singular_and_plural() {
-        assert_eq!(pluralize(0, "file", "files"), "0 files");
-        assert_eq!(pluralize(1, "file", "files"), "1 file");
-        assert_eq!(pluralize(2, "file", "files"), "2 files");
-        assert_eq!(pluralize(12, "branch", "branches"), "12 branches");
+        assert_eq!(pluralize(0_u64, "file"), "0 files");
+        assert_eq!(pluralize(1_u64, "file"), "1 file");
+        assert_eq!(pluralize(2_u64, "file"), "2 files");
+        assert_eq!(pluralize_with(12_u64, "branch", "branches"), "12 branches");
     }
 }

apps/desktop/src-tauri/src/file_system/git/log.rs

@@ -207,10 +207,10 @@ pub fn list_commits(handle: &RepoHandle, repo_root: &Path) -> Result<Vec<FileEnt
         // count, still a useful "size of this snapshot" cue.
         if let Some(n) = files_changed_count(&repo, id) {
             fe.size = Some(n);
-            fe.display_size = Some(column_meta::pluralize(n, "file", "files"));
+            fe.display_size = Some(column_meta::pluralize(n, "file"));
             fe.display_size_tooltip = Some(format!(
                 "{} changed compared to the parent commit",
-                column_meta::pluralize(n, "file", "files")
+                column_meta::pluralize(n, "file")
             ));
         }
         out.push(fe);