test: add comprehensive unit tests to forge-core modules

- rate_limiter: add tests for zero limit, reset timing, saturating sub
- circuit_breaker: add tests for zero limit, state transitions, edge cases
- io: add tests for read_json, append_history, edge cases
- prompt: add tests for analyze_plan, build_plan_prompt edge cases

Total: 116 tests now passing (was 96)

Author: puppe1990

crates/forge-core/src/circuit_breaker.rs

@@ -175,4 +175,78 @@ mod tests {
         assert!(cb.is_half_open());
         assert_eq!(cb.consecutive_no_progress(), 1);
     }
+
+    #[test]
+    fn zero_limit_opens_immediately() {
+        let mut cb = CircuitBreaker::new(0);
+
+        let action = cb.record_no_progress();
+
+        assert_eq!(action, CircuitBreakerAction::OpenCircuit);
+        assert!(cb.is_open());
+    }
+
+    #[test]
+    fn two_limit_opens_after_two_no_progress() {
+        let mut cb = CircuitBreaker::new(2);
+
+        cb.record_no_progress();
+        assert!(cb.is_half_open());
+
+        cb.record_no_progress();
+        assert!(cb.is_open());
+    }
+
+    #[test]
+    fn progress_closes_open_circuit() {
+        let mut cb = CircuitBreaker::new(1);
+
+        cb.record_no_progress();
+        assert!(cb.is_open());
+
+        let action = cb.record_progress();
+
+        assert_eq!(action, CircuitBreakerAction::Continue);
+        assert!(cb.is_closed());
+        assert_eq!(cb.consecutive_no_progress(), 0);
+    }
+
+    #[test]
+    fn from_state_with_open_circuit() {
+        let state = CircuitBreakerState {
+            state: CircuitState::Open,
+            consecutive_no_progress: 5,
+        };
+
+        let cb = CircuitBreaker::from_state(state, 10);
+
+        assert!(cb.is_open());
+        assert_eq!(cb.consecutive_no_progress(), 5);
+    }
+
+    #[test]
+    fn multiple_progress_calls_keep_closed() {
+        let mut cb = CircuitBreaker::new(3);
+
+        for _ in 0..10 {
+            cb.record_progress();
+        }
+
+        assert!(cb.is_closed());
+        assert_eq!(cb.consecutive_no_progress(), 0);
+    }
+
+    #[test]
+    fn no_progress_counter_saturates() {
+        let mut cb = CircuitBreaker::new(3);
+
+        cb.record_no_progress();
+        cb.record_no_progress();
+
+        assert_eq!(cb.consecutive_no_progress(), 2);
+
+        cb.record_no_progress();
+
+        assert_eq!(cb.consecutive_no_progress(), 3);
+    }
 }

crates/forge-core/src/io.rs

@@ -200,4 +200,80 @@ mod tests {
         assert!(path.exists());
         assert!(path.is_dir());
     }
+
+    #[test]
+    fn read_json_parses_valid_file() {
+        let dir = tempdir().expect("tempdir");
+        let path = dir.path().join("data.json");
+        let data = TestData {
+            name: "test".to_string(),
+            value: 42,
+        };
+
+        write_json(&path, &data).expect("write");
+        let read: TestData = read_json(&path).expect("read");
+
+        assert_eq!(read.name, "test");
+        assert_eq!(read.value, 42);
+    }
+
+    #[test]
+    fn read_json_fails_on_missing_file() {
+        let dir = tempdir().expect("tempdir");
+        let path = dir.path().join("missing.json");
+
+        let result: Result<TestData> = read_json(&path);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn read_json_fails_on_invalid_json() {
+        let dir = tempdir().expect("tempdir");
+        let path = dir.path().join("invalid.json");
+        fs::write(&path, "not json").expect("write");
+
+        let result: Result<TestData> = read_json(&path);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn append_history_handles_empty_string() {
+        let dir = tempdir().expect("tempdir");
+        let path = dir.path().join("log.txt");
+
+        append_history(&path, "").expect("append empty");
+
+        let content = fs::read_to_string(&path).expect("read");
+        assert!(content.is_empty());
+    }
+
+    #[test]
+    fn read_lines_reverse_handles_empty_file() {
+        let dir = tempdir().expect("tempdir");
+        let path = dir.path().join("empty.txt");
+        fs::write(&path, "").expect("write");
+
+        let lines = read_lines_reverse(&path, 10).expect("read");
+        assert!(lines.is_empty());
+    }
+
+    #[test]
+    fn read_lines_reverse_handles_only_whitespace() {
+        let dir = tempdir().expect("tempdir");
+        let path = dir.path().join("whitespace.txt");
+        fs::write(&path, "   \n   \n   \n").expect("write");
+
+        let lines = read_lines_reverse(&path, 10).expect("read");
+        assert!(lines.is_empty());
+    }
+
+    #[test]
+    fn ensure_dir_does_nothing_if_exists() {
+        let dir = tempdir().expect("tempdir");
+
+        ensure_dir(dir.path()).expect("first ensure");
+        ensure_dir(dir.path()).expect("second ensure");
+
+        assert!(dir.path().is_dir());
+    }
 }

crates/forge-core/src/prompt.rs

@@ -177,4 +177,59 @@ mod tests {
         assert!(prompt.contains("Task 79"));
         assert!(!prompt.contains("Task 80"));
     }
+
+    #[test]
+    fn build_plan_prompt_handles_whitespace_only_plan() {
+        let dir = tempdir().expect("tempdir");
+        let forge_dir = dir.path().join(".forge");
+        fs::create_dir_all(&forge_dir).expect("create .forge");
+        fs::write(forge_dir.join("plan.md"), "   \n\t\n").expect("write whitespace");
+
+        let result = build_plan_prompt(dir.path());
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn analyze_plan_counts_x_as_checked() {
+        let dir = tempdir().expect("tempdir");
+        let forge_dir = dir.path().join(".forge");
+        fs::create_dir_all(&forge_dir).expect("create .forge");
+        fs::write(
+            forge_dir.join("plan.md"),
+            "# Plan\n- [x] Done\n- [X] Also Done\n- [ ] Not Done\n",
+        )
+        .expect("write plan");
+
+        let summary = analyze_plan(dir.path()).expect("summary");
+        assert_eq!(summary.checked_items, 1);
+        assert_eq!(summary.unchecked_items, 1);
+    }
+
+    #[test]
+    fn analyze_plan_handles_empty_plan() {
+        let dir = tempdir().expect("tempdir");
+        let forge_dir = dir.path().join(".forge");
+        fs::create_dir_all(&forge_dir).expect("create .forge");
+        fs::write(forge_dir.join("plan.md"), "# Plan\n").expect("write empty plan");
+
+        let summary = analyze_plan(dir.path()).expect("summary");
+        assert_eq!(summary.total_items, 0);
+    }
+
+    #[test]
+    fn build_plan_prompt_includes_continuity_message() {
+        let dir = tempdir().expect("tempdir");
+        let forge_dir = dir.path().join(".forge");
+        fs::create_dir_all(&forge_dir).expect("create .forge");
+        fs::write(forge_dir.join("plan.md"), "- [ ] Test\n").expect("write plan");
+        fs::write(
+            forge_dir.join("progress.json"),
+            r#"{"last_summary": "completed step 1"}"#,
+        )
+        .expect("write progress");
+
+        let prompt = build_plan_prompt(dir.path()).expect("prompt");
+        assert!(prompt.contains("Last loop summary:"));
+        assert!(prompt.contains("completed step 1"));
+    }
 }

crates/forge-core/src/rate_limiter.rs

@@ -167,15 +167,29 @@ mod tests {
     }
 
     #[test]
-    fn returns_remaining_count() {
+    fn reset_at_exactly_one_hour() {
         let dir = tempdir().expect("tempdir");
-        let limiter = RateLimiter::new(10);
+        let limiter = RateLimiter::new(2);
 
-        let r1 = limiter.check_and_increment(dir.path(), 1000).expect("1");
-        assert_eq!(r1.remaining, 9);
+        limiter.check_and_increment(dir.path(), 1000).expect("1");
+        limiter.check_and_increment(dir.path(), 1001).expect("2");
 
-        let r2 = limiter.check_and_increment(dir.path(), 1001).expect("2");
-        assert_eq!(r2.remaining, 8);
+        let at_one_hour = limiter
+            .check_and_increment(dir.path(), 4600)
+            .expect("at one hour");
+        assert!(at_one_hour.allowed);
+        assert_eq!(at_one_hour.current_count, 1);
+
+        let after_one_hour = limiter
+            .check_and_increment(dir.path(), 5000)
+            .expect("after hour");
+        assert!(after_one_hour.allowed);
+        assert_eq!(after_one_hour.current_count, 2);
+
+        let over_limit = limiter
+            .check_and_increment(dir.path(), 5001)
+            .expect("over limit");
+        assert!(!over_limit.allowed);
     }
 
     #[test]
@@ -191,4 +205,40 @@ mod tests {
 
         assert_eq!(state.count, 2);
     }
+
+    #[test]
+    fn zero_limit_always_blocks() {
+        let dir = tempdir().expect("tempdir");
+        let limiter = RateLimiter::new(0);
+
+        let result = limiter
+            .check_and_increment(dir.path(), 1000)
+            .expect("check");
+
+        assert!(!result.allowed);
+        assert_eq!(result.current_count, 0);
+        assert_eq!(result.remaining, 0);
+    }
+
+    #[test]
+    fn saturating_sub_prevents_underflow() {
+        let dir = tempdir().expect("tempdir");
+        let limiter = RateLimiter::new(1);
+
+        limiter.check_and_increment(dir.path(), 1000).expect("1");
+
+        let result = limiter.check_and_increment(dir.path(), 1001).expect("2");
+        assert_eq!(result.remaining, 0);
+    }
+
+    #[test]
+    fn get_state_returns_default_for_missing_files() {
+        let dir = tempdir().expect("tempdir");
+        let limiter = RateLimiter::new(100);
+
+        let state = limiter.get_state(dir.path()).expect("state");
+
+        assert_eq!(state.count, 0);
+        assert_eq!(state.last_reset_epoch, 0);
+    }
 }