feat: add log.txt to config dir. this acts as a log file to provide more information for errors that the notification system cannot.

src/app.zig

···
 const config = &@import("./config.zig").config;
 const List = @import("./list.zig").List;
 const Directories = @import("./directories.zig");
+const FileLogger = @import("./file_logger.zig");
 const CircStack = @import("./circ_stack.zig").CircularStack;
 const zuid = @import("zuid");
 const vaxis = @import("vaxis");
···
 
 directories: Directories,
 notification: Notification,
+// Assigned in main after config parsing.
+file_logger: FileLogger = undefined,
 
 text_input: vaxis.widgets.TextInput,
 text_input_buf: [std.fs.max_path_bytes]u8 = undefined,
···
     self.text_input.deinit();
     self.vx.deinit(self.alloc, self.tty.anyWriter());
     self.tty.deinit();
+    self.file_logger.deinit();
 }
 
 pub fn run(self: *App) !void {
···
                         } else |err| switch (err) {
                             error.SyntaxError => {
                                 try self.notification.writeErr(.ConfigSyntaxError);
+                            },
+                            error.InvalidCharacter => {
+                                try self.notification.writeErr(.InvalidKeybind);
+                            },
+                            error.DuplicateKeybind => {
+                                try self.notification.writeErr(.DuplicateKeybinds);
                             },
                             else => {
                                 try self.notification.writeErr(.ConfigUnknownError);

src/config.zig

···
 const builtin = @import("builtin");
 const environment = @import("./environment.zig");
 const vaxis = @import("vaxis");
+const FileLogger = @import("file_logger.zig");
 const Notification = @import("./notification.zig");
 
 const CONFIG_NAME = "config.json";
···
 
         // Check duplicate keybinds
         {
+            var file_logger = try FileLogger.init(alloc);
+            defer file_logger.deinit();
+
             var key_map = std.AutoHashMap(u21, []const u8).init(alloc);
             defer {
                 var it = key_map.iterator();
···
 
                 const res = try key_map.getOrPut(codepoint);
                 if (res.found_existing) {
+                    const message = try std.fmt.allocPrint(
+                        alloc,
+                        "'{s}' and '{s}' have the same keybind: '{d}'",
+                        .{ res.value_ptr.*, field.name, codepoint },
+                    );
+                    defer alloc.free(message);
+
+                    file_logger.write(message, .err) catch {};
+
                     return error.DuplicateKeybind;
                 }
                 res.value_ptr.* = try alloc.dupe(u8, field.name);

src/file_logger.zig

···
+const std = @import("std");
+const environment = @import("environment.zig");
+const config = &@import("./config.zig").config;
+
+pub const LOG_PATH = "log.txt";
+
+const LogLevel = enum {
+    err,
+    info,
+    warn,
+
+    pub fn toString(level: LogLevel) []const u8 {
+        return switch (level) {
+            .err => "ERROR",
+            .info => "INFO",
+            .warn => "WARN",
+        };
+    }
+};
+
+const FileLogger = @This();
+
+alloc: std.mem.Allocator,
+dir: std.fs.Dir,
+
+pub fn init(alloc: std.mem.Allocator) !FileLogger {
+    const file_logger = FileLogger{
+        .alloc = alloc,
+        .dir = try config.configDir() orelse return error.UnableToFindConfigDir,
+    };
+
+    if (!environment.fileExists(file_logger.dir, LOG_PATH)) {
+        _ = try file_logger.dir.createFile(LOG_PATH, .{});
+    }
+
+    return file_logger;
+}
+
+pub fn deinit(self: FileLogger) void {
+    var dir = self.dir;
+    dir.close();
+}
+
+pub fn write(self: FileLogger, msg: []const u8, level: LogLevel) !void {
+    var log = try self.dir.openFile(LOG_PATH, .{ .mode = .write_only });
+    defer log.close();
+
+    const message = try std.fmt.allocPrint(
+        self.alloc,
+        "({d}) {s}: {s}\n",
+        .{ std.time.timestamp(), LogLevel.toString(level), msg },
+    );
+    defer self.alloc.free(message);
+
+    if (try log.tryLock(std.fs.File.Lock.shared)) {
+        defer log.unlock();
+        try log.seekFromEnd(0);
+        try log.writeAll(message);
+    }
+}

src/main.zig

···
 const std = @import("std");
 const builtin = @import("builtin");
 const App = @import("app.zig");
+const FileLogger = @import("file_logger.zig");
 const vaxis = @import("vaxis");
 const config = &@import("./config.zig").config;
 
···
             try app.notification.writeErr(.ConfigUnknownError);
         },
     };
+
+    app.file_logger = try FileLogger.init(alloc);
 
     try app.run();
 }