feat(verbose): add verbose mode with real-time output display

- Add OPENCODER_VERBOSE environment variable support
- Display opencode stdout/stderr in real-time when verbose enabled
- Add verbose logging throughout the main loop phases
- Log cycle start, phase transitions, task progress, and backoff info

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

Author: leocavalcante

src/config.zig

@@ -122,6 +122,11 @@ pub const Config = struct {
             config.task_pause_seconds = std.fmt.parseInt(u64, val, 10) catch defaults.task_pause_seconds;
         }
 
+        // OPENCODER_VERBOSE
+        if (std.posix.getenv("OPENCODER_VERBOSE")) |val| {
+            config.verbose = std.mem.eql(u8, val, "1") or std.mem.eql(u8, val, "true") or std.mem.eql(u8, val, "yes");
+        }
+
         return config;
     }
 };
@@ -176,3 +181,8 @@ test "Config.defaults has expected values" {
     try std.testing.expectEqual(false, config.verbose);
     try std.testing.expectEqual(@as(?[]const u8, null), config.user_hint);
 }
+
+test "verbose flag is in Config struct" {
+    const config = Config.defaults;
+    _ = config.verbose;
+}

src/executor.zig

@@ -346,7 +346,7 @@ pub const Executor = struct {
         return .failure;
     }
 
-    // Run opencode CLI and return output
+    // Run opencode CLI and return output with real-time stdout/stderr display
     fn runOpencode(self: *Executor, model: []const u8, title: []const u8, prompt: []const u8) ![]u8 {
         var args = std.ArrayListUnmanaged([]const u8){};
         defer args.deinit(self.allocator);
@@ -364,9 +364,9 @@ pub const Executor = struct {
         var child = std.process.Child.init(args.items, self.allocator);
         child.cwd = null; // Use current working directory
 
-        // Inherit stderr for opencode output, capture stdout for result checking
-        child.stderr_behavior = .Inherit;
+        // Capture both stdout and stderr for real-time display
         child.stdout_behavior = .Pipe;
+        child.stderr_behavior = .Pipe;
 
         // Create a new process group for the child so we can kill all descendants
         child.pgid = 0; // 0 means child creates its own process group
@@ -381,7 +381,7 @@ pub const Executor = struct {
             self.current_child_pgid = null;
         }
 
-        // Read stdout
+        // Read stdout and stderr in real-time, displaying output as it arrives
         var stdout_list = std.ArrayListUnmanaged(u8){};
 
         if (child.stdout) |stdout| {
@@ -393,6 +393,21 @@ pub const Executor = struct {
                     stdout_list.deinit(self.allocator);
                     return err;
                 };
+                // Display output in real-time
+                const chunk = buf[0..n];
+                self.log.logVerbose(chunk);
+            }
+        }
+
+        // Read stderr in real-time
+        if (child.stderr) |stderr| {
+            var buf: [4096]u8 = undefined;
+            while (true) {
+                const n = stderr.read(&buf) catch break;
+                if (n == 0) break;
+                // Display stderr output in real-time (prefixed to distinguish from stdout)
+                const chunk = buf[0..n];
+                self.log.logVerbose(chunk);
             }
         }
 

src/loop.zig

@@ -62,10 +62,30 @@ pub const Loop = struct {
             self.log.sayFmt("Hint: {s}", .{hint});
         }
 
+        if (self.cfg.verbose) {
+            self.log.logVerbose("Verbose mode enabled");
+            {
+                var buf: [64]u8 = undefined;
+                const msg = std.fmt.bufPrint(&buf, "Backoff base: {d}s", .{self.cfg.backoff_base}) catch "";
+                self.log.logVerbose(msg);
+            }
+            {
+                var buf: [64]u8 = undefined;
+                const msg = std.fmt.bufPrint(&buf, "Max retries: {d}", .{self.cfg.max_retries}) catch "";
+                self.log.logVerbose(msg);
+            }
+            {
+                var buf: [64]u8 = undefined;
+                const msg = std.fmt.bufPrint(&buf, "Task pause: {d}s", .{self.cfg.task_pause_seconds}) catch "";
+                self.log.logVerbose(msg);
+            }
+        }
+
         self.log.say("Running continuously (Ctrl+C to stop, Ctrl+C twice to force)");
         self.log.say("");
 
         while (!shutdown_requested) {
+            self.log.logVerbose("Starting new cycle");
             self.log.say("");
             self.log.sayFmt("[Cycle {d}]", .{self.st.cycle});
             self.log.setCycle(self.st.cycle);
@@ -75,13 +95,19 @@ pub const Loop = struct {
 
             // Planning phase
             if (!fsutil.fileExists(self.paths.current_plan) or self.st.phase == .planning) {
+                self.log.logVerbose("Phase: planning");
                 // Check for ideas first
                 var idea_list = ideas.loadAllIdeas(self.paths.ideas_dir, self.allocator, self.cfg.max_file_size) catch null;
 
                 var result: ExecutionResult = .failure;
 
                 if (idea_list) |*list| {
                     defer list.deinit();
+                    {
+                        var buf: [64]u8 = undefined;
+                        const msg = std.fmt.bufPrint(&buf, "Found {d} idea(s) in ideas queue", .{list.ideas.len}) catch "";
+                        self.log.logVerbose(msg);
+                    }
 
                     if (list.ideas.len == 1) {
                         // Single idea - use it directly
@@ -113,6 +139,7 @@ pub const Loop = struct {
                     } else {
                         // Multiple ideas - AI selects simplest one
                         self.log.sayFmt("[Cycle {d}] Found {d} idea(s) in queue", .{ self.st.cycle, list.ideas.len });
+                        self.log.logVerbose("Multiple ideas found, requesting AI selection");
 
                         // Format ideas for AI selection
                         const formatted = ideas.formatIdeasForSelection(list.ideas, self.allocator) catch |err| {
@@ -238,6 +265,7 @@ pub const Loop = struct {
             if (shutdown_requested) break;
 
             // Execution phase
+            self.log.logVerbose("Phase: execution");
             self.log.logFmt("[Cycle {d}] Executing tasks...", .{self.st.cycle});
 
             while (!shutdown_requested) {
@@ -268,6 +296,12 @@ pub const Loop = struct {
                 self.st.current_task_num += 1;
                 self.st.task_index += 1;
 
+                {
+                    var buf: [64]u8 = undefined;
+                    const msg = std.fmt.bufPrint(&buf, "Executing task {d}/{d}", .{ self.st.current_task_num, self.st.total_tasks }) catch "";
+                    self.log.logVerbose(msg);
+                }
+
                 const result = self.executor.runTask(
                     task.description,
                     self.st.cycle,
@@ -311,6 +345,7 @@ pub const Loop = struct {
                     self.log.logError("  Plan file may not be updated correctly");
                 };
 
+                self.log.logVerbose("Task marked complete, saving state");
                 try self.st.save(self.paths.state_file, self.allocator);
 
                 // Small pause between tasks
@@ -321,6 +356,7 @@ pub const Loop = struct {
             if (shutdown_requested) break;
 
             // Evaluation phase
+            self.log.logVerbose("Phase: evaluation");
             const eval_result = evaluator.evaluate(
                 self.executor,
                 self.paths.current_plan,
@@ -339,6 +375,7 @@ pub const Loop = struct {
 
             if (eval_result == .complete) {
                 self.log.sayFmt("[Cycle {d}] Complete, starting new cycle", .{self.st.cycle});
+                self.log.logVerbose("Evaluation result: complete");
 
                 // Archive plan
                 plan.archive(
@@ -361,6 +398,7 @@ pub const Loop = struct {
                 self.st.current_task_num = 0;
                 self.st.total_tasks = 0;
             } else {
+                self.log.logVerbose("Evaluation result: needs_work");
                 // Check if there are actually pending tasks
                 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});
@@ -385,6 +423,11 @@ pub const Loop = struct {
             }
 
             try self.st.save(self.paths.state_file, self.allocator);
+            {
+                var buf: [64]u8 = undefined;
+                const msg = std.fmt.bufPrint(&buf, "Cycle {d} complete, state saved", .{self.st.cycle -| 1}) catch "";
+                self.log.logVerbose(msg);
+            }
             self.log.sayFmt("[Cycle {d}] Complete", .{self.st.cycle -| 1});
         }
 
@@ -401,6 +444,11 @@ pub const Loop = struct {
 
     fn backoffSleep(self: *Loop) void {
         const sleep_time = self.cfg.backoff_base * 2;
+        if (self.cfg.verbose) {
+            var buf: [64]u8 = undefined;
+            const msg = std.fmt.bufPrint(&buf, "Backoff: sleeping for {d} seconds", .{sleep_time}) catch "Backoff sleep";
+            self.log.logVerbose(msg);
+        }
         std.Thread.sleep(@as(u64, sleep_time) * std.time.ns_per_s);
     }
 };
@@ -499,6 +547,9 @@ fn createTestPaths(allocator: Allocator) !fsutil.Paths {
     try std.fs.cwd().makePath(cycle_log_dir);
     try std.fs.cwd().makePath(history_dir);
 
+    const ideas_dir = try std.fs.path.join(allocator, &.{ temp_dir, "ideas" });
+    try std.fs.cwd().makePath(ideas_dir);
+
     return fsutil.Paths{
         .opencoder_dir = opencoder_dir,
         .state_file = state_file,
@@ -507,6 +558,7 @@ fn createTestPaths(allocator: Allocator) !fsutil.Paths {
         .cycle_log_dir = cycle_log_dir,
         .alerts_file = alerts_file,
         .history_dir = history_dir,
+        .ideas_dir = ideas_dir,
         .allocator = allocator,
     };
 }