Merge pull request #9 from jhonatanjunio/main

feat: add Windows (Git Bash) support

Author: claudioemmanuel

.github/workflows/release.yml

@@ -62,8 +62,23 @@ jobs:
           name: squeez-linux-aarch64
           path: squeez-linux-aarch64
 
+  build-windows-x86_64:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Build
+        run: cargo build --release --target x86_64-pc-windows-msvc
+      - name: Rename binary
+        run: mv target/x86_64-pc-windows-msvc/release/squeez.exe squeez-windows-x86_64.exe
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: squeez-windows-x86_64
+          path: squeez-windows-x86_64.exe
+
   release:
-    needs: [build-macos, build-linux-x86_64, build-linux-aarch64]
+    needs: [build-macos, build-linux-x86_64, build-linux-aarch64, build-windows-x86_64]
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -75,11 +90,13 @@ jobs:
           cd squeez-macos-universal && sha256sum squeez-macos-universal > ../checksums.sha256 && cd ..
           cd squeez-linux-x86_64 && sha256sum squeez-linux-x86_64 >> ../checksums.sha256 && cd ..
           cd squeez-linux-aarch64 && sha256sum squeez-linux-aarch64 >> ../checksums.sha256 && cd ..
+          cd squeez-windows-x86_64 && sha256sum squeez-windows-x86_64.exe >> ../checksums.sha256 && cd ..
       - name: Upload to release
         uses: softprops/action-gh-release@v1
         with:
           files: |
             squeez-macos-universal/squeez-macos-universal
             squeez-linux-x86_64/squeez-linux-x86_64
             squeez-linux-aarch64/squeez-linux-aarch64
+            squeez-windows-x86_64/squeez-windows-x86_64.exe
             checksums.sha256

.gitignore

@@ -2,3 +2,5 @@
 /bin/
 *.DS_Store
 .omc/
+docs/
+.worktrees/

Cargo.toml

@@ -12,6 +12,8 @@ name = "squeez"
 path = "src/lib.rs"
 
 [dependencies]
+
+[target.'cfg(unix)'.dependencies]
 libc = "0.2"
 
 [profile.release]

README.md

@@ -15,6 +15,8 @@ Token compression + context optimization for Claude Code, OpenCode, and GitHub C
 
 ## Install
 
+> **Windows users:** squeez requires **Git Bash** to run. PowerShell and CMD are not supported — the hooks and binary rely on a POSIX shell environment. Open Git Bash and run:
+
 ```bash
 curl -fsSL https://raw.githubusercontent.com/claudioemmanuel/squeez/main/install.sh | sh
 ```
@@ -130,7 +132,18 @@ SQUEEZ_DIR=~/.copilot/squeez ~/.claude/squeez/bin/squeez init --copilot
 
 ## Local development
 
-**Prerequisites:** Rust stable (`rustup update stable`), `bash`, macOS or Linux.
+**Prerequisites:** Rust stable, `bash` (Git Bash on Windows — PowerShell is not supported). Works on Windows (Git Bash), macOS, and Linux.
+
+Install Rust via [rustup](https://rust-lang.org/tools/install/):
+```bash
+# macOS / Linux
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Windows: download and run rustup-init.exe from https://rust-lang.org/tools/install/
+# Then restart your terminal so cargo is in PATH.
+# Windows users also need MSVC C++ Build Tools:
+# https://visualstudio.microsoft.com/visual-cpp-build-tools/
+```
 
 ```bash
 # 1. Clone

install.sh

@@ -17,44 +17,49 @@ case "$OS" in
       *) echo "ERROR: unsupported arch $ARCH" >&2; exit 1 ;;
     esac
     ;;
-  Windows*|MINGW*|CYGWIN*)
-    echo "ERROR: Windows não é suportado. Use macOS ou Linux." >&2
-    exit 1
+  Windows*|MINGW*|MSYS*|CYGWIN*)
+    BINARY="squeez-windows-x86_64.exe"
     ;;
   *) echo "ERROR: unsupported OS $OS" >&2; exit 1 ;;
 esac
 
+# Local binary name: squeez.exe on Windows, squeez elsewhere
+case "$OS" in
+  Windows*|MINGW*|MSYS*|CYGWIN*) BIN_NAME="squeez.exe" ;;
+  *) BIN_NAME="squeez" ;;
+esac
+
 mkdir -p "$INSTALL_DIR/bin" "$INSTALL_DIR/hooks" "$INSTALL_DIR/sessions" "$INSTALL_DIR/memory"
-chmod 700 "$INSTALL_DIR" "$INSTALL_DIR/sessions" "$INSTALL_DIR/memory"
+chmod 700 "$INSTALL_DIR" "$INSTALL_DIR/sessions" "$INSTALL_DIR/memory" 2>/dev/null || true
 
 echo "Downloading squeez binary for $OS/$ARCH..."
-curl -fsSL "$RELEASES/$BINARY" -o "$INSTALL_DIR/bin/squeez"
+curl -fsSL "$RELEASES/$BINARY" -o "$INSTALL_DIR/bin/$BIN_NAME"
 
 echo "Verifying checksum..."
 curl -fsSL "$RELEASES/checksums.sha256" -o /tmp/squeez-checksums.sha256
 expected=$(grep "$BINARY" /tmp/squeez-checksums.sha256 2>/dev/null | awk '{print $1}')
 rm -f /tmp/squeez-checksums.sha256
 if [ -z "$expected" ]; then
     echo "ERROR: could not find checksum for $BINARY in release" >&2
-    rm -f "$INSTALL_DIR/bin/squeez"
+    rm -f "$INSTALL_DIR/bin/$BIN_NAME"
     exit 1
 fi
 
-# Use sha256sum if available (Linux), otherwise fall back to shasum (macOS)
+# Use sha256sum if available (Linux/Windows Git Bash), otherwise fall back to shasum (macOS)
 if command -v sha256sum >/dev/null 2>&1; then
-    actual=$(sha256sum "$INSTALL_DIR/bin/squeez" | awk '{print $1}')
+    actual=$(sha256sum "$INSTALL_DIR/bin/$BIN_NAME" | awk '{print $1}')
 else
-    actual=$(shasum -a 256 "$INSTALL_DIR/bin/squeez" | awk '{print $1}')
+    actual=$(shasum -a 256 "$INSTALL_DIR/bin/$BIN_NAME" | awk '{print $1}')
 fi
 
 if [ "$expected" != "$actual" ]; then
     echo "ERROR: checksum mismatch — binary may be corrupted or tampered" >&2
-    rm -f "$INSTALL_DIR/bin/squeez"
+    rm -f "$INSTALL_DIR/bin/$BIN_NAME"
     exit 1
 fi
 echo "Checksum verified."
 
-chmod +x "$INSTALL_DIR/bin/squeez"
+chmod +x "$INSTALL_DIR/bin/$BIN_NAME" 2>/dev/null || true
 
 echo "Installing hooks..."
 curl -fsSL "$REPO_RAW/hooks/pretooluse.sh"     -o "$INSTALL_DIR/hooks/pretooluse.sh"
@@ -132,8 +137,8 @@ mkdir -p "$COPILOT_SQUEEZ_DIR/bin" "$COPILOT_SQUEEZ_DIR/hooks" \
 chmod 700 "$COPILOT_SQUEEZ_DIR" "$COPILOT_SQUEEZ_DIR/sessions" "$COPILOT_SQUEEZ_DIR/memory" 2>/dev/null || true
 
 # Symlink the same binary so SQUEEZ_DIR-aware calls work
-ln -sf "$INSTALL_DIR/bin/squeez" "$COPILOT_SQUEEZ_DIR/bin/squeez" 2>/dev/null || \
-    cp "$INSTALL_DIR/bin/squeez" "$COPILOT_SQUEEZ_DIR/bin/squeez"
+ln -sf "$INSTALL_DIR/bin/$BIN_NAME" "$COPILOT_SQUEEZ_DIR/bin/$BIN_NAME" 2>/dev/null || \
+    cp "$INSTALL_DIR/bin/$BIN_NAME" "$COPILOT_SQUEEZ_DIR/bin/$BIN_NAME"
 
 curl -fsSL "$REPO_RAW/hooks/copilot-pretooluse.sh"     -o "$INSTALL_DIR/hooks/copilot-pretooluse.sh"
 curl -fsSL "$REPO_RAW/hooks/copilot-session-start.sh"  -o "$INSTALL_DIR/hooks/copilot-session-start.sh"
@@ -143,7 +148,7 @@ chmod +x "$INSTALL_DIR/hooks/copilot-pretooluse.sh" \
          "$INSTALL_DIR/hooks/copilot-posttooluse.sh"
 
 # Seed Copilot instructions (writes ~/.copilot/copilot-instructions.md)
-"$INSTALL_DIR/bin/squeez" init --copilot 2>/dev/null || true
+"$INSTALL_DIR/bin/$BIN_NAME" init --copilot 2>/dev/null || true
 
 # Register hooks in ~/.copilot/settings.json (Copilot CLI hook format mirrors Claude Code)
 if [ -d "$HOME/.copilot" ]; then
@@ -183,7 +188,7 @@ os.replace(tmp, path)
 COPILOT_EOF
 fi
 
-version=$("$INSTALL_DIR/bin/squeez" --version 2>/dev/null || echo "squeez")
+version=$("$INSTALL_DIR/bin/$BIN_NAME" --version 2>/dev/null || echo "squeez")
 echo "✅ $version installed."
 echo ""
 echo "Claude Code:  Restart Claude Code to activate."

src/commands/init.rs

@@ -21,7 +21,7 @@ pub fn run() -> i32 {
 /// ~/.copilot/copilot-instructions.md so Copilot CLI picks it up
 /// at every session start (no hook system required).
 pub fn run_copilot() -> i32 {
-    let home = std::env::var("HOME").unwrap_or_default();
+    let home = crate::session::home_dir();
     // Honour SQUEEZ_DIR override, default to ~/.copilot/squeez
     let base = std::env::var("SQUEEZ_DIR")
         .unwrap_or_else(|_| format!("{}/.copilot/squeez", home));

src/commands/wrap.rs

@@ -2,15 +2,35 @@ use crate::config::Config;
 use crate::filter;
 use crate::{json_util, session};
 use std::io::Read;
-use std::os::unix::process::CommandExt;
 use std::process::{Command, Stdio};
+#[cfg(unix)]
 use std::sync::atomic::{AtomicI32, Ordering};
 use std::thread;
 use std::time::{Duration, Instant};
 
+#[cfg(unix)]
 static CHILD_PID: AtomicI32 = AtomicI32::new(-1);
 
+/// Returns a `Command` pre-configured to run `cmd` through the platform shell.
+/// Unix/Git Bash: `sh -c <cmd>`
+/// Windows native: `cmd /C <cmd>`
+fn shell_command(cmd: &str) -> Command {
+    #[cfg(windows)]
+    {
+        let mut c = Command::new("cmd");
+        c.args(["/C", cmd]);
+        c
+    }
+    #[cfg(not(windows))]
+    {
+        let mut c = Command::new("sh");
+        c.args(["-c", cmd]);
+        c
+    }
+}
+
 pub fn run(cmd_str: &str) -> i32 {
+    #[cfg(unix)]
     setup_signals();
     let config = Config::load();
 
@@ -20,23 +40,24 @@ pub fn run(cmd_str: &str) -> i32 {
 
     let start = Instant::now();
 
-    // Spawn via sh -c to handle pipes, &&, redirections, builtins
-    let mut child = match Command::new("sh")
-        .arg("-c")
-        .arg(cmd_str)
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .process_group(0)
-        .spawn()
+    // Spawn via platform shell to handle pipes, &&, redirections, builtins
+    let mut cmd = shell_command(cmd_str);
+    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
+    #[cfg(unix)]
     {
+        use std::os::unix::process::CommandExt;
+        cmd.process_group(0);
+    }
+    let mut child = match cmd.spawn() {
         Ok(c) => c,
         Err(e) => {
             eprintln!("squeez: {}", e);
             return 1;
         }
     };
 
-    // Store PID for signal forwarding
+    // Store PID for signal forwarding (Unix only)
+    #[cfg(unix)]
     CHILD_PID.store(child.id() as i32, Ordering::SeqCst);
 
     // Drain stdout/stderr on background threads to prevent pipe-buffer deadlock.
@@ -76,10 +97,11 @@ pub fn run(cmd_str: &str) -> i32 {
             Ok(Some(s)) => break s.code().unwrap_or(1),
             Ok(None) => {
                 if start.elapsed() >= timeout {
+                    #[cfg(unix)]
                     unsafe {
                         libc::kill(-(child.id() as i32), libc::SIGTERM);
+                        std::thread::sleep(Duration::from_millis(200));
                     }
-                    std::thread::sleep(Duration::from_millis(200));
                     let _ = child.kill();
                     eprintln!("squeez: command timed out after 120s");
                     let _ = stdout_thread.join();
@@ -148,9 +170,7 @@ pub fn run(cmd_str: &str) -> i32 {
 }
 
 fn passthrough(cmd: &str) -> i32 {
-    let status = Command::new("sh")
-        .arg("-c")
-        .arg(cmd)
+    let status = shell_command(cmd)
         .status()
         .unwrap_or_else(|e| {
             eprintln!("squeez: {}", e);
@@ -166,13 +186,15 @@ fn is_streaming(cmd: &str) -> bool {
         && cmd.split_whitespace().any(|a| a == "-f" || a == "--follow")
 }
 
+#[cfg(unix)]
 fn setup_signals() {
     unsafe {
         libc::signal(libc::SIGTERM, forward_signal as *const () as libc::sighandler_t);
         libc::signal(libc::SIGINT, forward_signal as *const () as libc::sighandler_t);
     }
 }
 
+#[cfg(unix)]
 extern "C" fn forward_signal(sig: libc::c_int) {
     let pid = CHILD_PID.load(Ordering::SeqCst);
     if pid > 0 {

src/config.rs

@@ -79,10 +79,7 @@ impl Config {
 
     pub fn load() -> Self {
         let base = std::env::var("SQUEEZ_DIR").unwrap_or_else(|_| {
-            format!(
-                "{}/.claude/squeez",
-                std::env::var("HOME").unwrap_or_default()
-            )
+            format!("{}/.claude/squeez", crate::session::home_dir())
         });
         let path = format!("{}/config.ini", base);
         std::fs::read_to_string(&path)

src/session.rs

@@ -3,15 +3,20 @@ use std::path::{Path, PathBuf};
 
 // ── Directory helpers ──────────────────────────────────────────────────────
 
+/// Returns the user's home directory.
+/// Tries `HOME` first (Unix/Git Bash), then `USERPROFILE` (Windows native).
+pub fn home_dir() -> String {
+    std::env::var("HOME")
+        .or_else(|_| std::env::var("USERPROFILE"))
+        .unwrap_or_default()
+}
+
 /// Returns the squeez state directory. Overridable via SQUEEZ_DIR env var (for tests).
 pub fn squeez_dir() -> PathBuf {
     if let Ok(d) = std::env::var("SQUEEZ_DIR") {
         return PathBuf::from(d);
     }
-    PathBuf::from(format!(
-        "{}/.claude/squeez",
-        std::env::var("HOME").unwrap_or_default()
-    ))
+    PathBuf::from(format!("{}/.claude/squeez", home_dir()))
 }
 
 pub fn sessions_dir() -> PathBuf {

tests/test_session.rs

@@ -99,3 +99,10 @@ fn test_unix_to_date_epoch_zero() {
     let date = squeez::session::unix_to_date(0);
     assert_eq!(date, "1970-01-01", "got: {}", date);
 }
+
+#[test]
+fn test_home_dir_returns_nonempty() {
+    // HOME (Unix) or USERPROFILE (Windows) must be set in any real environment.
+    let home = squeez::session::home_dir();
+    assert!(!home.is_empty(), "home_dir() returned empty string");
+}