refactor: extract generic Queue to utils.zig

pxp9 · claude · pxp9 · commit 1eaffc4c867c · 2026-01-23T02:24:05.000+01:00
- create generic Queue(T) function for thread-safe request queues
- replace TelegramQueue and AiQueue with Queue type aliases
- rename methods to post/next for consistency

Co-Authored-By: Claude Opus 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/src/ai.zig b/src/ai.zig
@@ -140,37 +140,7 @@ pub const AiRequest = union(AiRequestKind) {
     shutdown: void,
 };
 
-pub const AiQueue = struct {
-    mutex: std.Thread.Mutex = .{},
-    requests: std.ArrayList(AiRequest),
-    alloc: std.mem.Allocator,
-
-    pub fn init(alloc: std.mem.Allocator) AiQueue {
-        return .{
-            .requests = .empty,
-            .alloc = alloc,
-        };
-    }
-
-    pub fn deinit(self: *AiQueue) void {
-        self.requests.deinit(self.alloc);
-    }
-
-    pub fn postRequest(self: *AiQueue, request: AiRequest) !void {
-        self.mutex.lock();
-        defer self.mutex.unlock();
-        try self.requests.append(self.alloc, request);
-    }
-
-    pub fn getRequest(self: *AiQueue) ?AiRequest {
-        self.mutex.lock();
-        defer self.mutex.unlock();
-        if (self.requests.items.len == 0) return null;
-        const request = self.requests.items[0];
-        _ = self.requests.orderedRemove(0);
-        return request;
-    }
-};
+pub const AiQueue = utils.AiQueue;
 
 pub const MessageRole = enum {
     user,
@@ -195,7 +165,7 @@ pub fn aiAgentLoop(ctx: utils.AiThreadContext) void {
     }
 
     while (true) {
-        const req = ctx.request_queue.getRequest() orelse {
+        const req = ctx.request_queue.next() orelse {
             std.Thread.yield() catch {};
             continue;
         };
diff --git a/src/main.zig b/src/main.zig
@@ -150,7 +150,7 @@ pub fn main() !void {
     }
 
     std.log.info("Requesting chats from Telegram...", .{});
-    try telegram_queue.postRequest(.{ .load_chats = .{ .count = 20 } });
+    try telegram_queue.post(.{ .load_chats = .{ .count = 20 } });
 
     var selected_chat_idx: usize = 0;
 
@@ -296,7 +296,7 @@ fn handle_event(alloc: std.mem.Allocator, event: Event, state: *AppState) !i32 {
 
                     if (state.chats.items.len > 0) {
                         const first_chat = state.chats.items[0];
-                        try state.telegram_queue.postRequest(.{
+                        try state.telegram_queue.post(.{
                             .load_chat_history = .{
                                 .chat_id = first_chat.id,
                                 .limit = 10,
@@ -486,7 +486,7 @@ fn applyAiUpdateResult(alloc: std.mem.Allocator, state: *AppState, result: ai.Ai
         },
         .send_telegram => |msg| {
             const text_copy = try alloc.dupe(u8, msg.text);
-            try state.telegram_queue.postRequest(.{
+            try state.telegram_queue.post(.{
                 .send_message = .{ .chat_id = msg.chat_id, .text = text_copy },
             });
         },
@@ -495,7 +495,7 @@ fn applyAiUpdateResult(alloc: std.mem.Allocator, state: *AppState, result: ai.Ai
                 try std.fmt.allocPrint(alloc, "Message sent successfully to chat '{s}'", .{res.message})
             else
                 try std.fmt.allocPrint(alloc, "Chat '{s}' not found in your conversations", .{res.message});
-            try state.ai_queue.postRequest(.{ .tool_result = .{ .success = res.success, .message = message } });
+            try state.ai_queue.post(.{ .tool_result = .{ .success = res.success, .message = message } });
         },
     }
 }
@@ -542,7 +542,7 @@ fn handle_select_action(alloc: std.mem.Allocator, state: *AppState) !void {
             if (!state.chat_messages_cache.contains(selected_chat.id)) {
                 std.log.info("Requesting messages for chat: {s}", .{selected_chat.title});
                 state.loading_messages.* = true;
-                try state.telegram_queue.postRequest(.{
+                try state.telegram_queue.post(.{
                     .load_chat_history = .{ .chat_id = selected_chat.id, .limit = 10 },
                 });
             }
@@ -554,7 +554,7 @@ fn handle_select_action(alloc: std.mem.Allocator, state: *AppState) !void {
             const selected_chat = state.chats.items[state.selected_chat_idx.*];
             const message_text = try state.chat_input.toOwnedSlice();
             std.log.info("Sending message to chat {d}", .{selected_chat.id});
-            try state.telegram_queue.postRequest(.{
+            try state.telegram_queue.post(.{
                 .send_message = .{ .chat_id = selected_chat.id, .text = message_text },
             });
         },
@@ -634,7 +634,7 @@ fn handle_select_action(alloc: std.mem.Allocator, state: *AppState) !void {
             const enhanced_prompt = try chat_list.toOwnedSlice(alloc);
 
             state.llm_loading.* = true;
-            try state.ai_queue.postRequest(.{ .send_message = .{ .prompt = enhanced_prompt } });
+            try state.ai_queue.post(.{ .send_message = .{ .prompt = enhanced_prompt } });
         },
     }
 }
@@ -718,8 +718,8 @@ fn handle_key_action(alloc: std.mem.Allocator, state: *AppState, action: keybind
     switch (action) {
         .quit => {
             std.log.info("Quit requested, shutting down threads", .{});
-            state.telegram_queue.postRequest(.{ .shutdown = {} }) catch {};
-            state.ai_queue.postRequest(.{ .shutdown = {} }) catch {};
+            state.telegram_queue.post(.{ .shutdown = {} }) catch {};
+            state.ai_queue.post(.{ .shutdown = {} }) catch {};
             return 0;
         },
         .switch_mode => state.active_mode.* = switch (state.active_mode.*) {
diff --git a/src/telegram.zig b/src/telegram.zig
@@ -500,39 +500,11 @@ pub const TelegramRequest = union(TelegramRequestKind) {
     shutdown: void,
 };
 
-pub const TelegramQueue = struct {
-    mutex: std.Thread.Mutex = .{},
-    requests: std.ArrayList(TelegramRequest),
-    alloc: std.mem.Allocator,
-
-    pub fn init(alloc: std.mem.Allocator) TelegramQueue {
-        return .{
-            .requests = .empty,
-            .alloc = alloc,
-        };
-    }
-
-    pub fn deinit(self: *TelegramQueue) void {
-        self.requests.deinit(self.alloc);
-    }
-
-    pub fn postRequest(self: *TelegramQueue, request: TelegramRequest) !void {
-        self.mutex.lock();
-        defer self.mutex.unlock();
-        try self.requests.append(self.alloc, request);
-    }
-
-    pub fn nextRequest(self: *TelegramQueue) ?TelegramRequest {
-        self.mutex.lock();
-        defer self.mutex.unlock();
-        if (self.requests.items.len == 0) return null;
-        return self.requests.orderedRemove(0);
-    }
-};
+pub const TelegramQueue = utils.TelegramQueue;
 
 pub fn telegramUpdateLoop(ctx: utils.TelegramThreadContext) void {
     while (true) {
-        while (ctx.request_queue.nextRequest()) |request| {
+        while (ctx.request_queue.next()) |request| {
             switch (request) {
                 .load_chats => |req| {
                     std.log.info("Processing load_chats request, count={d}", .{req.count});
diff --git a/src/utils.zig b/src/utils.zig
@@ -20,17 +20,20 @@ pub const Event = union(enum) {
     ai_update: ai.AiUpdate,
 };
 
+pub const TelegramQueue = Queue(telegram.TelegramRequest);
+pub const AiQueue = Queue(ai.AiRequest);
+
 pub const TelegramThreadContext = struct {
     client: *tdlib.Client,
     loop: *vaxis.Loop(Event),
-    request_queue: *telegram.TelegramQueue,
+    request_queue: *TelegramQueue,
     alloc: std.mem.Allocator,
 };
 
 pub const AiThreadContext = struct {
     config: *ai.Config,
     loop: *vaxis.Loop(Event),
-    request_queue: *ai.AiQueue,
+    request_queue: *AiQueue,
     alloc: std.mem.Allocator,
 };
 
@@ -40,6 +43,40 @@ pub const InputMode = enum {
     chat_list,
 };
 
+pub fn Queue(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        mutex: std.Thread.Mutex = .{},
+        requests: std.ArrayList(T),
+        alloc: std.mem.Allocator,
+
+        pub fn init(alloc: std.mem.Allocator) Self {
+            return .{
+                .requests = .empty,
+                .alloc = alloc,
+            };
+        }
+
+        pub fn deinit(self: *Self) void {
+            self.requests.deinit(self.alloc);
+        }
+
+        pub fn post(self: *Self, request: T) !void {
+            self.mutex.lock();
+            defer self.mutex.unlock();
+            try self.requests.append(self.alloc, request);
+        }
+
+        pub fn next(self: *Self) ?T {
+            self.mutex.lock();
+            defer self.mutex.unlock();
+            if (self.requests.items.len == 0) return null;
+            return self.requests.orderedRemove(0);
+        }
+    };
+}
+
 pub const AppState = struct {
     vx: *vaxis.Vaxis,
     tty: *vaxis.Tty,
@@ -53,8 +90,8 @@ pub const AppState = struct {
     llm_loading: *bool,
     keybindings: *keybindings.KeyBindings,
     keymap: *keybindings.ModeKeymap,
-    telegram_queue: *telegram.TelegramQueue,
-    ai_queue: *ai.AiQueue,
+    telegram_queue: *TelegramQueue,
+    ai_queue: *AiQueue,
     chat_list_text_view: *TextView,
     chat_list_text_buffer: *TextViewBuffer,
     chat_text_view: *TextView,
