fix: create parent directories recursively to avoid FileNotFound on fresh systems

std.fs.makeDirAbsolute fails with FileNotFound when parent directories
(e.g. ~/.local/share) don't exist, which happens on fresh CI runners.
Added makeDirAbsoluteRecursive helper and use it everywhere XDG
directories are created.

Author: lilienblum

src/main.zig

@@ -87,10 +87,7 @@ fn acquireLock(allocator: std.mem.Allocator) !std.fs.File {
     const data_dir = try xdg.dataDir(allocator);
     defer allocator.free(data_dir);
 
-    std.fs.makeDirAbsolute(data_dir) catch |err| switch (err) {
-        error.PathAlreadyExists => {},
-        else => return err,
-    };
+    try xdg.makeDirAbsoluteRecursive(data_dir);
 
     const lock_path = try std.fmt.allocPrint(allocator, "{s}/lock", .{data_dir});
     defer allocator.free(lock_path);
@@ -279,10 +276,7 @@ fn installThirdParty(allocator: std.mem.Allocator, ref: cli.PackageRef, src_type
         const cache_dir = try xdg.cacheDir(allocator);
         defer allocator.free(cache_dir);
 
-        std.fs.makeDirAbsolute(cache_dir) catch |err| switch (err) {
-            error.PathAlreadyExists => {},
-            else => return err,
-        };
+        try xdg.makeDirAbsoluteRecursive(cache_dir);
 
         const archive_path = try std.fmt.allocPrint(allocator, "{s}/{s}.tar.gz", .{ cache_dir, pkg.name });
         defer allocator.free(archive_path);

src/resolver.zig

@@ -219,10 +219,7 @@ fn ensureIndexInner(allocator: std.mem.Allocator, refresh: bool) ![]const u8 {
     const cache_dir = try xdg.cacheDir(allocator);
     defer allocator.free(cache_dir);
 
-    std.fs.makeDirAbsolute(cache_dir) catch |err| switch (err) {
-        error.PathAlreadyExists => {},
-        else => return err,
-    };
+    try xdg.makeDirAbsoluteRecursive(cache_dir);
 
     const index_path = try std.fmt.allocPrint(allocator, "{s}/index.json", .{cache_dir});
     defer allocator.free(index_path);

src/store.zig

@@ -155,10 +155,7 @@ pub const Database = struct {
     pub fn save(self: *Database, path: []const u8) !void {
         // Ensure parent directory exists
         if (std.fs.path.dirname(path)) |dir| {
-            std.fs.makeDirAbsolute(dir) catch |err| switch (err) {
-                error.PathAlreadyExists => {},
-                else => return err,
-            };
+            try xdg.makeDirAbsoluteRecursive(dir);
         }
 
         var aw: std.Io.Writer.Allocating = .init(self.allocator);
@@ -347,10 +344,7 @@ pub const Database = struct {
         const bin_dir_path = try xdg.binDir(allocator);
         defer allocator.free(bin_dir_path);
 
-        std.fs.makeDirAbsolute(bin_dir_path) catch |err| switch (err) {
-            error.PathAlreadyExists => {},
-            else => return err,
-        };
+        try xdg.makeDirAbsoluteRecursive(bin_dir_path);
 
         var bin_dir = try std.fs.openDirAbsolute(bin_dir_path, .{});
         defer bin_dir.close();

src/xdg.zig

@@ -43,6 +43,20 @@ pub fn statePath(allocator: std.mem.Allocator) ![]const u8 {
     return std.fmt.allocPrint(allocator, "{s}/state.json", .{data});
 }
 
+pub fn makeDirAbsoluteRecursive(path: []const u8) !void {
+    std.fs.makeDirAbsolute(path) catch |err| switch (err) {
+        error.PathAlreadyExists => return,
+        error.FileNotFound => {
+            // Parent doesn't exist, create it first
+            if (std.fs.path.dirname(path)) |parent| {
+                try makeDirAbsoluteRecursive(parent);
+                try std.fs.makeDirAbsolute(path);
+            } else return err;
+        },
+        else => return err,
+    };
+}
+
 pub fn ensureDirs(allocator: std.mem.Allocator) !void {
     const data = try dataDir(allocator);
     defer allocator.free(data);
@@ -55,9 +69,6 @@ pub fn ensureDirs(allocator: std.mem.Allocator) !void {
 
     const dirs = [_][]const u8{ data, cache, bin };
     for (dirs) |dir| {
-        std.fs.makeDirAbsolute(dir) catch |err| switch (err) {
-            error.PathAlreadyExists => {},
-            else => return err,
-        };
+        try makeDirAbsoluteRecursive(dir);
     }
 }