Fix code review issues and CI build failure

This commit addresses all review comments from Copilot and fixes the GitHub Actions build failure:

Build Fix:
- Made cwd.zig macOS-only with comptime check to prevent Linux build failures
- Added conditional import of cwd_mod in state.zig (struct{} for non-macOS)
- Added early return in updateCwd for non-macOS platforms

Review #1 - Ping-pong animation:
- Replaced sawtooth animation with smooth ping-pong pattern
- Animation now includes forward scroll, backward scroll, and idle at both ends
- Eliminates jarring jump back to start

Review #2 - Fade conditions:
- Fixed inverted fade logic
- fade_left now correctly triggers when scroll_offset > 0
- fade_right now correctly triggers when scroll_offset < scroll_range

Review #3 - Documentation:
- Added documentation clarifying cwd_basename is a subslice of cwd_path
- Documents lifetime dependency between the two fields

Review #4 & #5 - Silent failure logging:
- Added log warnings for basename buffer overflow
- Added log warnings for parent path buffer overflow
- Helps debugging when paths exceed buffer limits

Review #6 - Remove unused field:
- Removed cwd_marquee_offset field (animation uses current_time instead)
- Cleaned up unused code

All fixes tested with:
- zig build: Success
- zig build test: All tests pass
- zig fmt src/: Code formatted

Author: forketyfork

src/cwd.zig

@@ -1,8 +1,15 @@
 const std = @import("std");
 const posix = std.posix;
+const builtin = @import("builtin");
 
 const log = std.log.scoped(.cwd);
 
+comptime {
+    if (builtin.os.tag != .macos) {
+        @compileError("cwd.zig: proc_pidinfo API is macOS-specific. This module should only be compiled on macOS.");
+    }
+}
+
 pub const CwdError = error{
     ProcessNotFound,
     BufferTooSmall,

src/render/renderer.zig

@@ -786,7 +786,13 @@ fn renderCwdBar(
         if (std.mem.eql(u8, cwd_basename, "/")) {
             break :blk cwd_basename;
         }
-        if (cwd_basename.len + 1 > basename_with_slash_buf.len) return;
+        if (cwd_basename.len + 1 > basename_with_slash_buf.len) {
+            log.warn("CWD basename too long for buffer (len={}, max_without_slash={}); skipping CWD bar rendering", .{
+                cwd_basename.len,
+                basename_with_slash_buf.len - 1,
+            });
+            return;
+        }
         @memcpy(basename_with_slash_buf[0..cwd_basename.len], cwd_basename);
         basename_with_slash_buf[cwd_basename.len] = '/';
         break :blk basename_with_slash_buf[0 .. cwd_basename.len + 1];
@@ -825,7 +831,13 @@ fn renderCwdBar(
         if (parent_without_slash[parent_without_slash.len - 1] == '/') {
             break :blk parent_without_slash;
         } else {
-            if (parent_without_slash.len + 1 > parent_path_buf.len) return;
+            if (parent_without_slash.len + 1 > parent_path_buf.len) {
+                log.warn(
+                    "render: parent path too long (required={} bytes, buffer size={}), skipping parent path rendering",
+                    .{ parent_without_slash.len + 1, parent_path_buf.len },
+                );
+                return;
+            }
             @memcpy(parent_path_buf[0..parent_without_slash.len], parent_without_slash);
             parent_path_buf[parent_without_slash.len] = '/';
             break :blk parent_path_buf[0 .. parent_without_slash.len + 1];
@@ -868,17 +880,33 @@ fn renderCwdBar(
         const scroll_range_f: f32 = @floatFromInt(scroll_range);
         const idle_ms: f32 = 1000.0;
         const scroll_ms: f32 = scroll_range_f / MARQUEE_SPEED * 1000.0;
-        const cycle_ms: f32 = idle_ms * 2.0 + scroll_ms;
+        const cycle_ms: f32 = idle_ms * 2.0 + scroll_ms * 2.0;
         const cycle_ms_i64: i64 = @max(1, @as(i64, @intFromFloat(std.math.ceil(cycle_ms))));
         const elapsed_ms: f32 = @floatFromInt(@mod(current_time, cycle_ms_i64));
 
         const scroll_offset: c_int = blk: {
+            // Phase 1: initial idle at start (offset = 0)
             if (elapsed_ms < idle_ms) break :blk 0;
-            if (elapsed_ms < idle_ms + scroll_ms) {
-                const progress = (elapsed_ms - idle_ms) / scroll_ms;
+
+            // Phase 2: forward scroll from 0 to scroll_range
+            const forward_start = idle_ms;
+            const forward_end = idle_ms + scroll_ms;
+            if (elapsed_ms < forward_end) {
+                const progress = (elapsed_ms - forward_start) / scroll_ms;
                 break :blk @intFromFloat(progress * scroll_range_f);
             }
-            break :blk scroll_range;
+
+            // Phase 3: idle at end (offset = scroll_range)
+            const end_idle_start = forward_end;
+            const end_idle_end = end_idle_start + idle_ms;
+            if (elapsed_ms < end_idle_end) {
+                break :blk scroll_range;
+            }
+
+            // Phase 4: backward scroll from scroll_range back to 0
+            const backward_start = end_idle_end;
+            const progress = (elapsed_ms - backward_start) / scroll_ms;
+            break :blk @intFromFloat((1.0 - progress) * scroll_range_f);
         };
 
         const parent_x = basename_x - parent_width + scroll_offset;
@@ -891,8 +919,8 @@ fn renderCwdBar(
 
         _ = c.SDL_SetRenderClipRect(renderer, null);
 
-        const fade_left = scroll_offset < scroll_range;
-        const fade_right = scroll_offset > 0;
+        const fade_left = scroll_offset > 0;
+        const fade_right = scroll_offset < scroll_range;
 
         if (fade_left) {
             renderFadeGradient(renderer, bar_rect, true);

src/session/state.zig

@@ -1,11 +1,12 @@
 const std = @import("std");
 const posix = std.posix;
+const builtin = @import("builtin");
 const ghostty_vt = @import("ghostty-vt");
 const shell_mod = @import("../shell.zig");
 const pty_mod = @import("../pty.zig");
 const app_state = @import("../app/app_state.zig");
 const c = @import("../c.zig");
-const cwd_mod = @import("../cwd.zig");
+const cwd_mod = if (builtin.os.tag == .macos) @import("../cwd.zig") else struct {};
 
 const log = std.log.scoped(.session_state);
 
@@ -40,9 +41,10 @@ pub const SessionState = struct {
     notify_sock_z: [:0]const u8,
     allocator: std.mem.Allocator,
     cwd_path: ?[]const u8 = null,
+    /// Subslice of cwd_path pointing to the basename. Always points within cwd_path's memory.
+    /// When cwd_path is freed, this becomes invalid and must not be used.
     cwd_basename: ?[]const u8 = null,
     cwd_last_check: i64 = 0,
-    cwd_marquee_offset: f32 = 0,
 
     pub const InitError = shell_mod.Shell.SpawnError || MakeNonBlockingError || error{
         DivisionByZero,
@@ -222,6 +224,8 @@ pub const SessionState = struct {
     }
 
     pub fn updateCwd(self: *SessionState, current_time: i64) void {
+        if (builtin.os.tag != .macos) return;
+
         if (!self.spawned or self.dead) return;
 
         const shell = self.shell orelse return;
@@ -244,7 +248,6 @@ pub const SessionState = struct {
 
         self.cwd_path = new_path;
         self.cwd_basename = cwd_mod.getBasename(new_path);
-        self.cwd_marquee_offset = 0;
         self.dirty = true;
     }
 };