Merge pull request #11 from taurean/improved-sleep-schedule

Improved sleep schedule

deno.json

···
     "config": "deno run --allow-read --allow-write setup.ts",
     "mount": "deno run --allow-net --allow-env --allow-read --env mount.ts",
     "watch": "deno run --allow-net --allow-env --env --watch main.ts",
-    "start": "deno run --allow-net --allow-env --env main.ts"
+    "start": "deno run --allow-net --allow-env --env main.ts",
+    "test": "deno test"
   },
   "imports": {
     "@std/assert": "jsr:@std/assert@1",

tasks/sendSleepMessage.ts

···
   agentContext,
   claimTaskThread,
   releaseTaskThread,
+  isAgentAsleep,
 } from "../utils/agentContext.ts";
 import {
   getNow,
···
 
   const now = getNow();
 
-  if (now.hour >= agentContext.sleepTime) {
+  if (isAgentAsleep(now.hour)) {
     console.log(`🔹 attempting to wind down ${agentContext.agentBskyName}`);
   } else {
     const delay = msUntilDailyWindow(

tasks/sendWakeMessage.ts

···
   agentContext,
   claimTaskThread,
   releaseTaskThread,
+  isAgentAwake,
 } from "../utils/agentContext.ts";
 import { getNow, msFrom, msRandomOffset } from "../utils/time.ts";
 import { messageAgent } from "../utils/messageAgent.ts";
···
 
   const now = getNow();
 
-  if (now.hour >= agentContext.wakeTime && now.hour < agentContext.sleepTime) {
+  if (isAgentAwake(now.hour)) {
     console.log(`🔹 attempting to wake up ${agentContext.agentBskyName}`);
   } else {
     const delay = msUntilDailyWindow(

utils/agentContext.test.ts

···
+import { assertEquals } from "@std/assert";
+import { isAgentAwake, isAgentAsleep } from "./sleepWakeHelpers.ts";
+
+// Normal Schedule Tests (wake=8, sleep=22)
+// Agent should be awake from 8am to 10pm
+
+Deno.test("Normal schedule - should be asleep before wake time (7am)", () => {
+  assertEquals(isAgentAwake(7, 8, 22), false);
+  assertEquals(isAgentAsleep(7, 8, 22), true);
+});
+
+Deno.test("Normal schedule - should be awake at wake time (8am)", () => {
+  assertEquals(isAgentAwake(8, 8, 22), true);
+  assertEquals(isAgentAsleep(8, 8, 22), false);
+});
+
+Deno.test("Normal schedule - should be awake during day (12pm)", () => {
+  assertEquals(isAgentAwake(12, 8, 22), true);
+  assertEquals(isAgentAsleep(12, 8, 22), false);
+});
+
+Deno.test("Normal schedule - should be awake before sleep time (9pm)", () => {
+  assertEquals(isAgentAwake(21, 8, 22), true);
+  assertEquals(isAgentAsleep(21, 8, 22), false);
+});
+
+Deno.test("Normal schedule - should be asleep at sleep time (10pm)", () => {
+  assertEquals(isAgentAwake(22, 8, 22), false);
+  assertEquals(isAgentAsleep(22, 8, 22), true);
+});
+
+Deno.test("Normal schedule - should be asleep late night (11pm)", () => {
+  assertEquals(isAgentAwake(23, 8, 22), false);
+  assertEquals(isAgentAsleep(23, 8, 22), true);
+});
+
+Deno.test("Normal schedule - should be asleep at midnight", () => {
+  assertEquals(isAgentAwake(0, 8, 22), false);
+  assertEquals(isAgentAsleep(0, 8, 22), true);
+});
+
+// Cross-Midnight Schedule Tests (wake=9, sleep=2)
+// Agent should be awake from 9am to 2am (next day)
+
+Deno.test("Cross-midnight schedule - should be awake at midnight", () => {
+  assertEquals(isAgentAwake(0, 9, 2), true);
+  assertEquals(isAgentAsleep(0, 9, 2), false);
+});
+
+Deno.test("Cross-midnight schedule - should be awake late night (1am)", () => {
+  assertEquals(isAgentAwake(1, 9, 2), true);
+  assertEquals(isAgentAsleep(1, 9, 2), false);
+});
+
+Deno.test("Cross-midnight schedule - should be asleep at sleep time (2am)", () => {
+  assertEquals(isAgentAwake(2, 9, 2), false);
+  assertEquals(isAgentAsleep(2, 9, 2), true);
+});
+
+Deno.test("Cross-midnight schedule - should be asleep early morning (3am)", () => {
+  assertEquals(isAgentAwake(3, 9, 2), false);
+  assertEquals(isAgentAsleep(3, 9, 2), true);
+});
+
+Deno.test("Cross-midnight schedule - should be asleep before wake (8am)", () => {
+  assertEquals(isAgentAwake(8, 9, 2), false);
+  assertEquals(isAgentAsleep(8, 9, 2), true);
+});
+
+Deno.test("Cross-midnight schedule - should be awake at wake time (9am)", () => {
+  assertEquals(isAgentAwake(9, 9, 2), true);
+  assertEquals(isAgentAsleep(9, 9, 2), false);
+});
+
+Deno.test("Cross-midnight schedule - should be awake during day (12pm)", () => {
+  assertEquals(isAgentAwake(12, 9, 2), true);
+  assertEquals(isAgentAsleep(12, 9, 2), false);
+});
+
+Deno.test("Cross-midnight schedule - should be awake late night (11pm)", () => {
+  assertEquals(isAgentAwake(23, 9, 2), true);
+  assertEquals(isAgentAsleep(23, 9, 2), false);
+});
+
+// Edge Case Tests
+
+Deno.test("Edge case - equal wake/sleep times (midnight) should be asleep", () => {
+  // When wake == sleep, the agent should be asleep at all hours
+  assertEquals(isAgentAwake(0, 0, 0), false);
+  assertEquals(isAgentAsleep(0, 0, 0), true);
+  assertEquals(isAgentAwake(12, 0, 0), false);
+  assertEquals(isAgentAsleep(12, 0, 0), true);
+});
+
+Deno.test("Edge case - nearly 24 hours awake (wake=1, sleep=0)", () => {
+  // Asleep only from midnight to 1am
+  assertEquals(isAgentAwake(0, 1, 0), false);
+  assertEquals(isAgentAsleep(0, 1, 0), true);
+  assertEquals(isAgentAwake(1, 1, 0), true);
+  assertEquals(isAgentAsleep(1, 1, 0), false);
+  assertEquals(isAgentAwake(23, 1, 0), true);
+  assertEquals(isAgentAsleep(23, 1, 0), false);
+});
+
+Deno.test("Edge case - nearly 24 hours asleep (wake=0, sleep=23)", () => {
+  // Awake only from midnight to 11pm
+  assertEquals(isAgentAwake(0, 0, 23), true);
+  assertEquals(isAgentAsleep(0, 0, 23), false);
+  assertEquals(isAgentAwake(22, 0, 23), true);
+  assertEquals(isAgentAsleep(22, 0, 23), false);
+  assertEquals(isAgentAwake(23, 0, 23), false);
+  assertEquals(isAgentAsleep(23, 0, 23), true);
+});
+
+Deno.test("Edge case - adjacent hours (wake=10, sleep=11)", () => {
+  // Awake only from 10am to 11am
+  assertEquals(isAgentAwake(9, 10, 11), false);
+  assertEquals(isAgentAsleep(9, 10, 11), true);
+  assertEquals(isAgentAwake(10, 10, 11), true);
+  assertEquals(isAgentAsleep(10, 10, 11), false);
+  assertEquals(isAgentAwake(11, 10, 11), false);
+  assertEquals(isAgentAsleep(11, 10, 11), true);
+  assertEquals(isAgentAwake(12, 10, 11), false);
+  assertEquals(isAgentAsleep(12, 10, 11), true);
+});
+
+// Inverse Relationship Tests
+
+Deno.test("Inverse relationship - awake and asleep are always opposite (normal schedule)", () => {
+  const wakeTime = 8;
+  const sleepTime = 22;
+
+  // Test all 24 hours
+  for (let hour = 0; hour < 24; hour++) {
+    const awake = isAgentAwake(hour, wakeTime, sleepTime);
+    const asleep = isAgentAsleep(hour, wakeTime, sleepTime);
+    assertEquals(
+      awake,
+      !asleep,
+      `Hour ${hour}: awake=${awake}, asleep=${asleep} should be opposite`,
+    );
+  }
+});
+
+Deno.test("Inverse relationship - awake and asleep are always opposite (cross-midnight)", () => {
+  const wakeTime = 9;
+  const sleepTime = 2;
+
+  // Test all 24 hours
+  for (let hour = 0; hour < 24; hour++) {
+    const awake = isAgentAwake(hour, wakeTime, sleepTime);
+    const asleep = isAgentAsleep(hour, wakeTime, sleepTime);
+    assertEquals(
+      awake,
+      !asleep,
+      `Hour ${hour}: awake=${awake}, asleep=${asleep} should be opposite`,
+    );
+  }
+});
+
+Deno.test("Inverse relationship - awake and asleep are always opposite (edge case)", () => {
+  const wakeTime = 23;
+  const sleepTime = 1;
+
+  // Test all 24 hours
+  for (let hour = 0; hour < 24; hour++) {
+    const awake = isAgentAwake(hour, wakeTime, sleepTime);
+    const asleep = isAgentAsleep(hour, wakeTime, sleepTime);
+    assertEquals(
+      awake,
+      !asleep,
+      `Hour ${hour}: awake=${awake}, asleep=${asleep} should be opposite`,
+    );
+  }
+});

utils/agentContext.ts

···
 } from "./const.ts";
 import { msFrom } from "./time.ts";
 import { bsky } from "./bsky.ts";
+import {
+  isAgentAsleep as checkIsAsleep,
+  isAgentAwake as checkIsAwake,
+} from "./sleepWakeHelpers.ts";
 
 export const getLettaApiKey = (): string => {
   const value = Deno.env.get("LETTA_API_KEY")?.trim();
···
   agentContext.replyCount = 0;
   agentContext.quoteCount = 0;
 };
+
+export const isAgentAwake = (hour: number): boolean => {
+  return checkIsAwake(hour, agentContext.wakeTime, agentContext.sleepTime);
+};
+
+export const isAgentAsleep = (hour: number): boolean => {
+  return checkIsAsleep(hour, agentContext.wakeTime, agentContext.sleepTime);
+};

utils/sleepWakeHelpers.ts

···
+/**
+ * Helper functions for determining agent sleep/wake status
+ * These functions handle both normal schedules and cross-midnight schedules
+ */
+
+/**
+ * Core logic: Determines if agent should be asleep at given hour
+ */
+export const isAgentAsleep = (
+  hour: number,
+  wakeTime: number,
+  sleepTime: number,
+): boolean => {
+  // Edge case: if wake == sleep, agent has zero awake time (always asleep)
+  if (wakeTime === sleepTime) {
+    return true;
+  }
+
+  // If sleepTime > wakeTime: normal same-day schedule (e.g., wake=8, sleep=22)
+  // Agent is asleep from sleepTime until midnight, OR from midnight until wakeTime
+  if (sleepTime > wakeTime) {
+    return hour >= sleepTime || hour < wakeTime;
+  }
+
+  // If sleepTime < wakeTime: schedule crosses midnight (e.g., wake=9, sleep=2)
+  // Agent is asleep from sleepTime until wakeTime (same day)
+  return hour >= sleepTime && hour < wakeTime;
+};
+
+/**
+ * Semantic wrapper: Determines if agent should be awake at given hour
+ * Simply the inverse of isAgentAsleep
+ */
+export const isAgentAwake = (
+  hour: number,
+  wakeTime: number,
+  sleepTime: number,
+): boolean => {
+  return !isAgentAsleep(hour, wakeTime, sleepTime);
+};