feat(config): make hardcoded values configurable via environment variables

Add three new configuration options that can be overridden by environment variables:
- OPENCODER_MAX_FILE_SIZE: Maximum file size for reading files (default: 1MB)
- OPENCODER_LOG_BUFFER_SIZE: Buffer size for logger formatting (default: 2KB)
- OPENCODER_TASK_PAUSE_SECONDS: Pause duration between tasks (default: 2s)

Changes:
- Add max_file_size, log_buffer_size, task_pause_seconds to Config struct
- Update Config.loadFromEnv() to parse new environment variables
- Update fsutil.readFile() to accept max_size parameter
- Update Logger to use dynamic buffer allocation based on buffer_size
- Thread config values through all modules that need them
- Update all tests to include new config fields

This allows users to tune opencoder behavior without code changes.

Signed-off-by: leocavalcante <[email protected]>

Author: leocavalcante

src/config.zig

@@ -76,6 +76,9 @@ pub const Config = struct {
     max_retries: u32,
     backoff_base: u32,
     log_retention: u32,
+    max_file_size: usize,
+    log_buffer_size: usize,
+    task_pause_seconds: u64,
 
     /// Default configuration values
     pub const defaults = Config{
@@ -87,6 +90,9 @@ pub const Config = struct {
         .max_retries = 3,
         .backoff_base = 10,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024, // 1MB
+        .log_buffer_size = 2048, // 2KB
+        .task_pause_seconds = 2, // 2 seconds
     };
 
     /// Load configuration from environment variables
@@ -108,6 +114,21 @@ pub const Config = struct {
             config.log_retention = std.fmt.parseInt(u32, val, 10) catch defaults.log_retention;
         }
 
+        // OPENCODER_MAX_FILE_SIZE (in bytes)
+        if (std.posix.getenv("OPENCODER_MAX_FILE_SIZE")) |val| {
+            config.max_file_size = std.fmt.parseInt(usize, val, 10) catch defaults.max_file_size;
+        }
+
+        // OPENCODER_LOG_BUFFER_SIZE (in bytes)
+        if (std.posix.getenv("OPENCODER_LOG_BUFFER_SIZE")) |val| {
+            config.log_buffer_size = std.fmt.parseInt(usize, val, 10) catch defaults.log_buffer_size;
+        }
+
+        // OPENCODER_TASK_PAUSE_SECONDS
+        if (std.posix.getenv("OPENCODER_TASK_PAUSE_SECONDS")) |val| {
+            config.task_pause_seconds = std.fmt.parseInt(u64, val, 10) catch defaults.task_pause_seconds;
+        }
+
         return config;
     }
 };
@@ -164,6 +185,9 @@ test "Config.defaults has expected values" {
     try std.testing.expectEqual(@as(u32, 3), config.max_retries);
     try std.testing.expectEqual(@as(u32, 10), config.backoff_base);
     try std.testing.expectEqual(@as(u32, 30), config.log_retention);
+    try std.testing.expectEqual(@as(usize, 1024 * 1024), config.max_file_size);
+    try std.testing.expectEqual(@as(usize, 2048), config.log_buffer_size);
+    try std.testing.expectEqual(@as(u64, 2), config.task_pause_seconds);
     try std.testing.expectEqual(false, config.verbose);
     try std.testing.expectEqual(@as(?[]const u8, null), config.user_hint);
 }

src/evaluator.zig

@@ -25,10 +25,11 @@ pub fn evaluate(
     plan_path: []const u8,
     cycle: u32,
     allocator: Allocator,
+    max_size: usize,
 ) !EvaluationResult {
     // First check if all tasks are marked complete
     const pending_tasks = blk: {
-        const content = fsutil.readFile(plan_path, allocator) catch |err| {
+        const content = fsutil.readFile(plan_path, allocator, max_size) catch |err| {
             if (err == error.FileNotFound) {
                 // No plan file, needs work (planning)
                 return .needs_work;
@@ -54,8 +55,8 @@ pub fn evaluate(
 }
 
 /// Quick check if plan has pending tasks without AI evaluation
-pub fn hasPendingTasks(plan_path: []const u8, allocator: Allocator) bool {
-    const content = fsutil.readFile(plan_path, allocator) catch {
+pub fn hasPendingTasks(plan_path: []const u8, allocator: Allocator, max_size: usize) bool {
+    const content = fsutil.readFile(plan_path, allocator, max_size) catch {
         return false;
     };
     defer allocator.free(content);

src/executor.zig

@@ -271,6 +271,7 @@ fn createTestLogger(allocator: Allocator) !*Logger {
         .cycle = 0,
         .verbose = false,
         .allocator = allocator,
+        .buffer_size = 2048,
     };
     return logger_ptr;
 }
@@ -299,6 +300,9 @@ test "Executor.init creates executor" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     const executor = Executor.init(&test_cfg, test_logger, allocator);
@@ -320,6 +324,9 @@ test "Executor.initWithCmd creates executor with custom command" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     const executor = Executor.initWithCmd(&test_cfg, test_logger, allocator, "./test_helpers/mock_opencode.sh");
@@ -345,6 +352,9 @@ test "runOpencode handles successful execution" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     // Get absolute path to mock script
@@ -377,6 +387,9 @@ test "runOpencode handles process failure" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     // Get absolute path to mock script
@@ -406,6 +419,9 @@ test "runOpencode passes session ID when continuing" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     // Get absolute path to mock script

src/fs.zig

@@ -91,10 +91,10 @@ pub fn fileExists(path: []const u8) bool {
 }
 
 /// Read entire file contents
-pub fn readFile(path: []const u8, allocator: Allocator) ![]u8 {
+pub fn readFile(path: []const u8, allocator: Allocator, max_size: usize) ![]u8 {
     const file = try fs.cwd().openFile(path, .{});
     defer file.close();
-    return try file.readToEndAlloc(allocator, 1024 * 1024); // 1MB max
+    return try file.readToEndAlloc(allocator, max_size);
 }
 
 /// Write contents to file
@@ -168,7 +168,7 @@ test "readFile and writeFile work correctly" {
     try writeFile(test_file, content);
 
     // Read file
-    const read_content = try readFile(test_file, allocator);
+    const read_content = try readFile(test_file, allocator, 1024 * 1024);
     defer allocator.free(read_content);
 
     try std.testing.expectEqualStrings(content, read_content);

src/logger.zig

@@ -17,12 +17,14 @@ pub const Logger = struct {
     cycle: u32,
     verbose: bool,
     allocator: Allocator,
+    buffer_size: usize,
 
     /// Initialize logger with opencoder directory
     pub fn init(
         opencoder_dir: []const u8,
         verbose: bool,
         allocator: Allocator,
+        buffer_size: usize,
     ) !Logger {
         // Open main log file
         const main_log_path = try std.fs.path.join(allocator, &.{ opencoder_dir, "logs", "main.log" });
@@ -47,6 +49,7 @@ pub const Logger = struct {
             .cycle = 1,
             .verbose = verbose,
             .allocator = allocator,
+            .buffer_size = buffer_size,
         };
     }
 
@@ -71,8 +74,9 @@ pub const Logger = struct {
 
     /// Log message with formatting
     pub fn logFmt(self: *Logger, comptime fmt: []const u8, args: anytype) void {
-        var buf: [2048]u8 = undefined;
-        const msg = std.fmt.bufPrint(&buf, fmt, args) catch return;
+        const buf = self.allocator.alloc(u8, self.buffer_size) catch return;
+        defer self.allocator.free(buf);
+        const msg = std.fmt.bufPrint(buf, fmt, args) catch return;
         self.log(msg);
     }
 
@@ -86,8 +90,9 @@ pub const Logger = struct {
 
     /// Say with formatting
     pub fn sayFmt(self: *Logger, comptime fmt: []const u8, args: anytype) void {
-        var buf: [2048]u8 = undefined;
-        const msg = std.fmt.bufPrint(&buf, fmt, args) catch return;
+        const buf = self.allocator.alloc(u8, self.buffer_size) catch return;
+        defer self.allocator.free(buf);
+        const msg = std.fmt.bufPrint(buf, fmt, args) catch return;
         self.say(msg);
     }
 
@@ -100,8 +105,9 @@ pub const Logger = struct {
 
     /// Status with formatting
     pub fn statusFmt(self: *Logger, comptime fmt: []const u8, args: anytype) void {
-        var buf: [2048]u8 = undefined;
-        const msg = std.fmt.bufPrint(&buf, fmt, args) catch return;
+        const buf = self.allocator.alloc(u8, self.buffer_size) catch return;
+        defer self.allocator.free(buf);
+        const msg = std.fmt.bufPrint(buf, fmt, args) catch return;
         self.status(msg);
     }
 
@@ -113,16 +119,18 @@ pub const Logger = struct {
 
     /// Log error with formatting
     pub fn logErrorFmt(self: *Logger, comptime fmt: []const u8, args: anytype) void {
-        var buf: [2048]u8 = undefined;
-        const msg = std.fmt.bufPrint(&buf, fmt, args) catch return;
+        const buf = self.allocator.alloc(u8, self.buffer_size) catch return;
+        defer self.allocator.free(buf);
+        const msg = std.fmt.bufPrint(buf, fmt, args) catch return;
         self.logError(msg);
     }
 
     /// Log verbose (only if verbose mode enabled)
     pub fn logVerbose(self: *Logger, msg: []const u8) void {
         if (self.verbose) {
-            var buf: [2048]u8 = undefined;
-            const verbose_msg = std.fmt.bufPrint(&buf, "VERBOSE: {s}", .{msg}) catch return;
+            const buf = self.allocator.alloc(u8, self.buffer_size) catch return;
+            defer self.allocator.free(buf);
+            const verbose_msg = std.fmt.bufPrint(buf, "VERBOSE: {s}", .{msg}) catch return;
             self.say(verbose_msg);
         }
     }

src/loop.zig

@@ -89,7 +89,7 @@ pub const Loop = struct {
                 }
 
                 // Validate plan content
-                const plan_content = fsutil.readFile(self.paths.current_plan, self.allocator) catch {
+                const plan_content = fsutil.readFile(self.paths.current_plan, self.allocator, self.cfg.max_file_size) catch {
                     self.log.logError("Failed to read plan file");
                     self.backoffSleep();
                     continue;
@@ -115,7 +115,7 @@ pub const Loop = struct {
             self.log.logFmt("[Cycle {d}] Executing tasks...", .{self.st.cycle});
 
             while (!shutdown_requested) {
-                const plan_content = fsutil.readFile(self.paths.current_plan, self.allocator) catch {
+                const plan_content = fsutil.readFile(self.paths.current_plan, self.allocator, self.cfg.max_file_size) catch {
                     self.log.logError("Failed to read plan file");
                     break;
                 };
@@ -162,14 +162,14 @@ pub const Loop = struct {
                 }
 
                 // Mark task complete regardless of result to not get stuck
-                plan.markTaskComplete(self.paths.current_plan, task.line_number, self.allocator) catch {
+                plan.markTaskComplete(self.paths.current_plan, task.line_number, self.allocator, self.cfg.max_file_size) catch {
                     self.log.logError("Failed to mark task complete");
                 };
 
                 try self.st.save(self.paths.state_file, self.allocator);
 
                 // Small pause between tasks
-                std.Thread.sleep(2 * std.time.ns_per_s);
+                std.Thread.sleep(self.cfg.task_pause_seconds * std.time.ns_per_s);
             }
 
             // Evaluation phase
@@ -178,6 +178,7 @@ pub const Loop = struct {
                 self.paths.current_plan,
                 self.st.cycle,
                 self.allocator,
+                self.cfg.max_file_size,
             ) catch |err| {
                 self.log.logErrorFmt("Evaluation error: {}", .{err});
                 // Default to needs_work on error
@@ -206,7 +207,7 @@ pub const Loop = struct {
                 self.executor.resetSession();
             } else {
                 // Check if there are actually pending tasks
-                if (!evaluator.hasPendingTasks(self.paths.current_plan, self.allocator)) {
+                if (!evaluator.hasPendingTasks(self.paths.current_plan, self.allocator, self.cfg.max_file_size)) {
                     self.log.sayFmt("[Cycle {d}] NEEDS_WORK but no tasks, starting new cycle", .{self.st.cycle});
 
                     // Archive and start fresh
@@ -294,6 +295,7 @@ fn createTestLogger(allocator: Allocator) !*Logger {
         .cycle = 0,
         .verbose = false,
         .allocator = allocator,
+        .buffer_size = 2048,
     };
     return logger_ptr;
 }
@@ -370,6 +372,9 @@ test "Loop.init creates loop with correct fields" {
         .max_retries = 3,
         .backoff_base = 5,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     var test_state = state.State.default();
@@ -415,6 +420,9 @@ test "backoffSleep calculates correct sleep time" {
         .max_retries = 3,
         .backoff_base = 10,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     var test_state = state.State.default();
@@ -465,6 +473,9 @@ test "Loop state transitions between phases" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     var test_state = state.State.default();
@@ -519,6 +530,9 @@ test "Loop handles task counter increments" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     var test_state = state.State.default();
@@ -571,6 +585,9 @@ test "Loop cycle reset on new cycle" {
         .max_retries = 3,
         .backoff_base = 1,
         .log_retention = 30,
+        .max_file_size = 1024 * 1024,
+        .log_buffer_size = 2048,
+        .task_pause_seconds = 2,
     };
 
     var test_state = state.State{

src/main.zig

@@ -60,14 +60,14 @@ fn runOpencoder(cfg: config.Config, allocator: std.mem.Allocator) !void {
     defer paths.deinit();
 
     // Initialize logger
-    var log = try Logger.init(paths.opencoder_dir, cfg.verbose, allocator);
+    var log = try Logger.init(paths.opencoder_dir, cfg.verbose, allocator, cfg.log_buffer_size);
     defer log.deinit();
 
     log.say("Workspace initialized");
 
     // Load or create state
     var st = blk: {
-        if (try state.State.load(paths.state_file, allocator)) |loaded| {
+        if (try state.State.load(paths.state_file, allocator, cfg.max_file_size)) |loaded| {
             log.sayFmt("Resuming: Cycle {d}, Phase {s}", .{
                 loaded.cycle,
                 loaded.phase.toString(),
@@ -81,7 +81,7 @@ fn runOpencoder(cfg: config.Config, allocator: std.mem.Allocator) !void {
 
     // Recalculate task counts if resuming with existing plan
     if (fsutil.fileExists(paths.current_plan)) {
-        const plan_content = fsutil.readFile(paths.current_plan, allocator) catch null;
+        const plan_content = fsutil.readFile(paths.current_plan, allocator, cfg.max_file_size) catch null;
         if (plan_content) |content| {
             defer allocator.free(content);
             const plan_mod = @import("plan.zig");

src/plan.zig

@@ -94,9 +94,9 @@ pub fn countTotalTasks(plan_content: []const u8) u32 {
 }
 
 /// Mark a task as complete at the given line number
-pub fn markTaskComplete(path: []const u8, line_number: usize, allocator: Allocator) !void {
+pub fn markTaskComplete(path: []const u8, line_number: usize, allocator: Allocator, max_size: usize) !void {
     // Read file
-    const content = try fsutil.readFile(path, allocator);
+    const content = try fsutil.readFile(path, allocator, max_size);
     defer allocator.free(content);
 
     // Build new content with task marked complete