feat(windows): Implement CI (#185)

* chore(windows): Add CI

* feat(windows): fix remaining tests

Author: cwoolum

.gitattributes

@@ -0,0 +1,4 @@
+*.rs       text eol=lf
+Cargo.toml text eol=lf
+Cargo.lock text eol=lf
+.gitignore text eol=lf

.github/workflows/rust.yml

@@ -90,6 +90,47 @@ jobs:
       - name: Run tests
         run: cargo test --locked --workspace --lib --bins --test '*' --exclude fig_desktop-fuzz
 
+  cargo-clippy-windows-chat-cli:
+    name: Clippy Windows (chat_cli)
+    runs-on: windows-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/[email protected]
+        id: toolchain
+        with:
+          components: clippy
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: cargo-clippy-windows-chat-cli-${{ hashFiles('**/Cargo.lock') }}-${{ steps.toolchain.outputs.cachekey }}
+      - run: cargo clippy --locked -p chat_cli --color always -- -D warnings
+
+  cargo-test-windows-chat-cli:
+    name: Test Windows (chat_cli)
+    runs-on: windows-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+        id: toolchain
+        with:
+          components: llvm-tools-preview
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: cargo-test-windows-chat-cli-${{ hashFiles('**/Cargo.lock') }}-${{ steps.toolchain.outputs.cachekey }}
+      - name: Run tests
+        run: cargo test --locked -p chat_cli
+
   cargo-fmt:
     name: Fmt
     runs-on: ubuntu-latest

crates/chat-cli/src/cli/chat/tools/mod.rs

@@ -359,7 +359,8 @@ fn format_path(cwd: impl AsRef<Path>, path: impl AsRef<Path>) -> String {
         .map(|p| p.to_string_lossy().to_string())
         // If we have three consecutive ".." then it should probably just stay as an absolute path.
         .map(|p| {
-            if p.starts_with("../../..") {
+            let three_up = format!("..{}..{}..", std::path::MAIN_SEPARATOR, std::path::MAIN_SEPARATOR);
+            if p.starts_with(&three_up) {
                 path.as_ref().to_string_lossy().to_string()
             } else {
                 p
@@ -376,6 +377,10 @@ fn supports_truecolor(ctx: &Context) -> bool {
 
 #[cfg(test)]
 mod tests {
+    use std::path::MAIN_SEPARATOR;
+
+    use chat_cli::platform::ACTIVE_USER_HOME;
+
     use super::*;
     use crate::platform::EnvProvider;
 
@@ -384,15 +389,12 @@ mod tests {
         let ctx = Context::builder().with_test_home().await.unwrap().build_fake();
 
         let actual = sanitize_path_tool_arg(&ctx, "~");
-        assert_eq!(
-            actual,
-            ctx.fs().chroot_path(ctx.env().home().unwrap()),
-            "tilde should expand"
-        );
+        let expected_home = ctx.env().home().unwrap_or_default();
+        assert_eq!(actual, ctx.fs().chroot_path(&expected_home), "tilde should expand");
         let actual = sanitize_path_tool_arg(&ctx, "~/hello");
         assert_eq!(
             actual,
-            ctx.fs().chroot_path(ctx.env().home().unwrap().join("hello")),
+            ctx.fs().chroot_path(expected_home.join("hello")),
             "tilde should expand"
         );
         let actual = sanitize_path_tool_arg(&ctx, "/~");
@@ -412,15 +414,39 @@ mod tests {
             let path = sanitize_path_tool_arg(&ctx, path);
             fs.create_dir_all(&cwd).await.unwrap();
             fs.create_dir_all(&path).await.unwrap();
-            // Using `contains` since the chroot test directory will prefix the formatted path with a tmpdir
-            // path.
-            assert!(format_path(cwd, path).contains(expected));
+
+            let formatted = format_path(&cwd, &path);
+
+            if Path::new(expected).is_absolute() {
+                // If the expected path is relative, we need to ensure it is relative to the cwd.
+                let expected = fs.chroot_path_str(expected);
+
+                assert!(formatted == expected, "Expected '{}' to be '{}'", formatted, expected);
+
+                return;
+            }
+
+            assert!(
+                formatted.contains(expected),
+                "Expected '{}' to be '{}'",
+                formatted,
+                expected
+            );
         }
-        assert_paths("/Users/testuser/src", "/Users/testuser/Downloads", "../Downloads").await;
+
+        // Test relative path from src to Downloads (sibling directories)
+        assert_paths(
+            format!("{ACTIVE_USER_HOME}{MAIN_SEPARATOR}src").as_str(),
+            format!("{ACTIVE_USER_HOME}{MAIN_SEPARATOR}Downloads").as_str(),
+            format!("..{MAIN_SEPARATOR}Downloads").as_str(),
+        )
+        .await;
+
+        // Test absolute path that should stay absolute (going up too many levels)
         assert_paths(
-            "/Users/testuser/projects/MyProject/src",
-            "/Volumes/projects/MyProject/src",
-            "/Volumes/projects/MyProject/src",
+            format!("{ACTIVE_USER_HOME}{MAIN_SEPARATOR}projects{MAIN_SEPARATOR}some{MAIN_SEPARATOR}project").as_str(),
+            format!("{ACTIVE_USER_HOME}{MAIN_SEPARATOR}other").as_str(),
+            format!("{ACTIVE_USER_HOME}{MAIN_SEPARATOR}other").as_str(),
         )
         .await;
     }

crates/chat-cli/src/platform/fs/windows.rs

@@ -36,11 +36,15 @@ pub(super) fn append(a: impl AsRef<Path>, b: impl AsRef<Path>) -> PathBuf {
         let b_normal_components: Vec<_> = cleaned_b.components().collect();
 
         if b_normal_components.len() >= a_normal_components.len() {
-            // Check if the beginning of b matches a
+            // Check if the beginning of b matches a (case-insensitive on Windows)
             let matches = a_normal_components
                 .iter()
                 .zip(b_normal_components.iter())
-                .all(|(a_comp, b_comp)| a_comp == b_comp);
+                .all(|(a_comp, b_comp)| {
+                    // Case-insensitive comparison for Windows
+                    a_comp.as_os_str().to_string_lossy().to_lowercase()
+                        == b_comp.as_os_str().to_string_lossy().to_lowercase()
+                });
 
             if matches {
                 // Create a new path with a's components removed from the beginning of b

crates/chat-cli/src/platform/mod.rs

@@ -84,6 +84,15 @@ pub struct ContextBuilder {
     platform: Option<Platform>,
 }
 
+pub const WINDOWS_USER_HOME: &str = "C:\\Users\\testuser";
+pub const UNIX_USER_HOME: &str = "/home/testuser";
+
+pub const ACTIVE_USER_HOME: &str = if cfg!(windows) {
+    WINDOWS_USER_HOME
+} else {
+    UNIX_USER_HOME
+};
+
 impl ContextBuilder {
     pub fn new() -> Self {
         Self::default()
@@ -132,11 +141,19 @@ impl ContextBuilder {
     /// [Fs] and [Env] currently set with the builder.
     #[cfg(test)]
     pub async fn with_test_home(mut self) -> Result<Self, std::io::Error> {
-        let home = "/home/testuser";
         let fs = Fs::new_chroot();
-        fs.create_dir_all(home).await?;
+        fs.create_dir_all(ACTIVE_USER_HOME).await?;
         self.fs = Some(fs);
-        self.env = Some(Env::from_slice(&[("HOME", "/home/testuser"), ("USER", "testuser")]));
+
+        if cfg!(windows) {
+            self.env = Some(Env::from_slice(&[
+                ("USERPROFILE", ACTIVE_USER_HOME),
+                ("USERNAME", "testuser"),
+            ]));
+        } else {
+            self.env = Some(Env::from_slice(&[("HOME", ACTIVE_USER_HOME), ("USER", "testuser")]));
+        }
+
         Ok(self)
     }
 
@@ -165,8 +182,18 @@ mod tests {
             .unwrap()
             .with_env_var("hello", "world")
             .build();
-        assert!(ctx.fs().try_exists("/home/testuser").await.unwrap());
-        assert_eq!(ctx.env().get("HOME").unwrap(), "/home/testuser");
+
+        #[cfg(windows)]
+        {
+            assert!(ctx.fs().try_exists(WINDOWS_USER_HOME).await.unwrap());
+            assert_eq!(ctx.env().get("USERPROFILE").unwrap(), WINDOWS_USER_HOME);
+        }
+        #[cfg(not(windows))]
+        {
+            assert!(ctx.fs().try_exists(UNIX_USER_HOME).await.unwrap());
+            assert_eq!(ctx.env().get("HOME").unwrap(), UNIX_USER_HOME);
+        }
+
         assert_eq!(ctx.env().get("hello").unwrap(), "world");
     }
 }

crates/chat-cli/src/util/directories.rs

@@ -52,7 +52,22 @@ pub fn home_dir(#[cfg_attr(windows, allow(unused_variables))] ctx: &Context) ->
     }
 
     #[cfg(windows)]
-    dirs::home_dir().ok_or(DirectoryError::NoHomeDirectory)
+    match cfg!(test) {
+        true => ctx
+            .env()
+            .get("USERPROFILE")
+            .map_err(|_err| DirectoryError::NoHomeDirectory)
+            .and_then(|h| {
+                if h.is_empty() {
+                    Err(DirectoryError::NoHomeDirectory)
+                } else {
+                    Ok(h)
+                }
+            })
+            .map(PathBuf::from)
+            .map(|p| ctx.fs().chroot_path(p)),
+        false => dirs::home_dir().ok_or(DirectoryError::NoHomeDirectory),
+    }
 }
 
 /// The q data directory