kernelbot 1.0.33 → 1.0.35

package/src/utils/timeUtils.js

@@ -0,0 +1,110 @@
+/**
+ * Quiet Hours utility — configurable "Do Not Disturb" schedule.
+ *
+ * Resolution order (first defined wins):
+ *   1. Environment variables  QUIET_HOURS_START / QUIET_HOURS_END  (HH:mm)
+ *   2. YAML config values     config.life.quiet_hours.start / .end (integer hour)
+ *   3. Built-in defaults      02:00 – 06:00
+ *
+ * If neither variable is set, quiet hours are disabled (returns false).
+ */
+
+/** Default quiet-hours window (integer hours). */
+const DEFAULT_START = 2;
+const DEFAULT_END = 6;
+
+/**
+ * Resolve the active quiet-hours window into a normalised { startMinutes, endMinutes } pair.
+ * Both values are in "minutes since midnight" (0 – 1439).
+ *
+ * @param {object} [lifeConfig] - Optional `config.life` object from YAML.
+ * @returns {{ startMinutes: number, endMinutes: number }}
+ */
+function resolveWindow(lifeConfig) {
+  const envStart = process.env.QUIET_HOURS_START;
+  const envEnd = process.env.QUIET_HOURS_END;
+
+  if (envStart && envEnd) {
+    const [startH, startM] = envStart.split(':').map(Number);
+    const [endH, endM] = envEnd.split(':').map(Number);
+
+    if (!isNaN(startH) && !isNaN(startM) && !isNaN(endH) && !isNaN(endM)) {
+      return { startMinutes: startH * 60 + startM, endMinutes: endH * 60 + endM };
+    }
+  }
+
+  const startHour = lifeConfig?.quiet_hours?.start ?? DEFAULT_START;
+  const endHour = lifeConfig?.quiet_hours?.end ?? DEFAULT_END;
+  return { startMinutes: startHour * 60, endMinutes: endHour * 60 };
+}
+
+/**
+ * Check whether a given "minutes since midnight" value falls inside a quiet window.
+ *
+ * @param {number} current - Current minutes since midnight.
+ * @param {number} start   - Window start (minutes since midnight).
+ * @param {number} end     - Window end   (minutes since midnight).
+ * @returns {boolean}
+ */
+function insideWindow(current, start, end) {
+  if (start <= end) {
+    return current >= start && current < end;
+  }
+  // Window crosses midnight (e.g. 22:00 – 06:00)
+  return current >= start || current < end;
+}
+
+/**
+ * Check whether the current time falls within "quiet hours".
+ *
+ * @param {object} [lifeConfig] - Optional `config.life` object from YAML.
+ *   When provided, `lifeConfig.quiet_hours.start` / `.end` (integer hours)
+ *   act as the second-priority source before the hardcoded defaults.
+ * @returns {boolean} `true` when the current time is inside the quiet window.
+ */
+export function isQuietHours(lifeConfig) {
+  const { startMinutes, endMinutes } = resolveWindow(lifeConfig);
+  const now = new Date();
+  const currentMinutes = now.getHours() * 60 + now.getMinutes();
+  return insideWindow(currentMinutes, startMinutes, endMinutes);
+}
+
+/**
+ * Return the resolved quiet-hours configuration for logging / status display.
+ *
+ * @param {object} [lifeConfig] - Optional `config.life` object from YAML.
+ * @returns {{ start: string, end: string, active: boolean }}
+ *   `start` / `end` are formatted as "HH:MM", `active` reflects the current state.
+ */
+export function getQuietHoursConfig(lifeConfig) {
+  const { startMinutes, endMinutes } = resolveWindow(lifeConfig);
+  const pad = (n) => String(n).padStart(2, '0');
+  const fmt = (m) => `${pad(Math.floor(m / 60))}:${pad(m % 60)}`;
+  return {
+    start: fmt(startMinutes),
+    end: fmt(endMinutes),
+    active: isQuietHours(lifeConfig),
+  };
+}
+
+/**
+ * Calculate the number of milliseconds remaining until the current quiet-hours
+ * window ends.  Returns `0` when quiet hours are not active.
+ *
+ * Useful for deferring non-essential work until the window closes.
+ *
+ * @param {object} [lifeConfig] - Optional `config.life` object from YAML.
+ * @returns {number} Milliseconds until quiet hours end (0 if not currently quiet).
+ */
+export function msUntilQuietEnd(lifeConfig) {
+  if (!isQuietHours(lifeConfig)) return 0;
+
+  const { endMinutes } = resolveWindow(lifeConfig);
+  const now = new Date();
+  const currentMinutes = now.getHours() * 60 + now.getMinutes();
+
+  let diff = endMinutes - currentMinutes;
+  if (diff <= 0) diff += 24 * 60; // crosses midnight
+
+  return diff * 60_000;
+}

package/src/utils/truncate.js

@@ -0,0 +1,42 @@
+/**
+ * Shared tool-result truncation logic.
+ * Used by both OrchestratorAgent and WorkerAgent to cap tool outputs
+ * before feeding them back into the LLM context window.
+ */
+
+const MAX_RESULT_LENGTH = 3000;
+
+const LARGE_FIELDS = [
+  'stdout', 'stderr', 'content', 'diff', 'output',
+  'body', 'html', 'text', 'log', 'logs',
+];
+
+/**
+ * Truncate a serialized tool result to fit within the context budget.
+ *
+ * Strategy:
+ *   1. If JSON.stringify(result) fits, return it as-is.
+ *   2. Otherwise, trim known large string fields to 500 chars each and retry.
+ *   3. If still too large, hard-slice the serialized string.
+ *
+ * @param {string} _name - Tool name (reserved for future per-tool limits)
+ * @param {any} result - Raw tool result object
+ * @returns {string} JSON string, guaranteed ≤ MAX_RESULT_LENGTH (+tail note)
+ */
+export function truncateToolResult(_name, result) {
+  let str = JSON.stringify(result);
+  if (str.length <= MAX_RESULT_LENGTH) return str;
+
+  if (result && typeof result === 'object') {
+    const truncated = { ...result };
+    for (const field of LARGE_FIELDS) {
+      if (typeof truncated[field] === 'string' && truncated[field].length > 500) {
+        truncated[field] = truncated[field].slice(0, 500) + `\n... [truncated ${truncated[field].length - 500} chars]`;
+      }
+    }
+    str = JSON.stringify(truncated);
+    if (str.length <= MAX_RESULT_LENGTH) return str;
+  }
+
+  return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
+}

package/src/worker.js

@@ -5,9 +5,7 @@ import { getMissingCredential } from './utils/config.js';
 import { getWorkerPrompt } from './prompts/workers.js';
 import { getUnifiedSkillById } from './skills/custom.js';
 import { getLogger } from './utils/logger.js';
-
-const MAX_RESULT_LENGTH = 3000;
-const LARGE_FIELDS = ['stdout', 'stderr', 'content', 'diff', 'output', 'body', 'html', 'text', 'log', 'logs'];
+import { truncateToolResult } from './utils/truncate.js';
 
 /**
  * WorkerAgent — runs a scoped agent loop in the background.
@@ -371,21 +369,7 @@ export class WorkerAgent {
   }
 
   _truncateResult(name, result) {
-    let str = JSON.stringify(result);
-    if (str.length <= MAX_RESULT_LENGTH) return str;
-
-    if (result && typeof result === 'object') {
-      const truncated = { ...result };
-      for (const field of LARGE_FIELDS) {
-        if (typeof truncated[field] === 'string' && truncated[field].length > 500) {
-          truncated[field] = truncated[field].slice(0, 500) + `\n... [truncated ${truncated[field].length - 500} chars]`;
-        }
-      }
-      str = JSON.stringify(truncated);
-      if (str.length <= MAX_RESULT_LENGTH) return str;
-    }
-
-    return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
+    return truncateToolResult(name, result);
   }
 
   _formatToolSummary(name, input) {