kernelbot 1.0.38 → 1.0.40

package/src/utils/timeAwareness.js

@@ -0,0 +1,72 @@
+/**
+ * Time Awareness Utility — Riyadh-local helpers.
+ *
+ * Provides timezone-aware helpers anchored to Asia/Riyadh so that
+ * automated tasks can respect the user's real-world schedule.
+ *
+ * Quiet hours (02:00 – 10:00 Riyadh time) are intentionally wider than
+ * the generic defaults in timeUtils.js because the owner fasts during
+ * Ramadan and typically sleeps through the early-morning hours.
+ *
+ * @module utils/timeAwareness
+ */
+
+const TIMEZONE = 'Asia/Riyadh';
+const QUIET_START_HOUR = 2;
+const QUIET_END_HOUR = 10;
+
+/**
+ * Return the current date/time in the Asia/Riyadh timezone.
+ *
+ * The returned object contains the full ISO-style formatted string,
+ * the numeric hour (0-23), and the raw Date for further processing.
+ *
+ * @returns {{ formatted: string, hour: number, date: Date }}
+ */
+export function getCurrentRiyadhTime() {
+  const now = new Date();
+
+  const formatted = now.toLocaleString('en-US', {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: true,
+    timeZone: TIMEZONE,
+  });
+
+  const hourParts = new Intl.DateTimeFormat('en-US', {
+    hour: 'numeric',
+    hour12: false,
+    timeZone: TIMEZONE,
+  }).formatToParts(now);
+
+  const hour = parseInt(
+    hourParts.find((p) => p.type === 'hour')?.value || '0',
+    10,
+  );
+
+  return { formatted, hour, date: now };
+}
+
+/**
+ * Check whether the current Riyadh time falls within quiet hours.
+ *
+ * Quiet hours are defined as **02:00 – 10:00 (Asia/Riyadh)** to
+ * respect the user's sleep schedule during Ramadan fasting, when
+ * they tend to sleep through the early-morning period.
+ *
+ * Automated tasks (notifications, self-improvement PRs, noisy jobs)
+ * should check this flag and defer non-urgent work until after the
+ * quiet window closes.
+ *
+ * @returns {boolean} `true` when the current Riyadh time is between
+ *   02:00 and 10:00 (inclusive start, exclusive end).
+ */
+export function isQuietHours() {
+  const { hour } = getCurrentRiyadhTime();
+  return hour >= QUIET_START_HOUR && hour < QUIET_END_HOUR;
+}

package/src/worker.js

@@ -3,7 +3,7 @@ import { executeTool } from './tools/index.js';
 import { closeSession } from './tools/browser.js';
 import { getMissingCredential } from './utils/config.js';
 import { getWorkerPrompt } from './prompts/workers.js';
-import { getUnifiedSkillById } from './skills/custom.js';
+import { buildSkillPrompt } from './skills/loader.js';
 import { getLogger } from './utils/logger.js';
 import { truncateToolResult } from './utils/truncate.js';
 
@@ -23,17 +23,17 @@ export class WorkerAgent {
    * @param {string} opts.workerType - coding, browser, system, devops, research
    * @param {string} opts.jobId - Job ID for logging
    * @param {Array} opts.tools - Scoped tool definitions
-   * @param {string|null} opts.skillId - Active skill ID (for worker prompt)
+   * @param {string[]|null} opts.skillIds - Active skill IDs (for worker prompt)
    * @param {string|null} opts.workerContext - Structured context (conversation history, persona, dependency results)
    * @param {object} opts.callbacks - { onProgress, onComplete, onError }
    * @param {AbortController} opts.abortController - For cancellation
    */
-  constructor({ config, workerType, jobId, tools, skillId, workerContext, callbacks, abortController }) {
+  constructor({ config, workerType, jobId, tools, skillIds, workerContext, callbacks, abortController }) {
     this.config = config;
     this.workerType = workerType;
     this.jobId = jobId;
     this.tools = tools;
-    this.skillId = skillId;
+    this.skillIds = skillIds || [];
     this.workerContext = workerContext || null;
     this.callbacks = callbacks || {};
     this.abortController = abortController || new AbortController();
@@ -45,8 +45,8 @@ export class WorkerAgent {
     // Create provider from worker brain config
     this.provider = createProvider(config);
 
-    // Build system prompt
-    const skillPrompt = skillId ? getUnifiedSkillById(skillId)?.systemPrompt : null;
+    // Build system prompt with combined skill expertise
+    const skillPrompt = buildSkillPrompt(this.skillIds);
     this.systemPrompt = getWorkerPrompt(workerType, config, skillPrompt);
 
     // Safety ceiling — not a real limit, just prevents infinite loops
@@ -54,7 +54,7 @@ export class WorkerAgent {
     this.maxIterations = 200;
 
     const logger = getLogger();
-    logger.info(`[Worker ${jobId}] Created: type=${workerType}, provider=${config.brain.provider}/${config.brain.model}, tools=${tools.length}, skill=${skillId || 'none'}, context=${workerContext ? 'yes' : 'none'}`);
+    logger.info(`[Worker ${jobId}] Created: type=${workerType}, provider=${config.brain.provider}/${config.brain.model}, tools=${tools.length}, skills=${this.skillIds.length > 0 ? this.skillIds.join(',') : 'none'}, context=${workerContext ? 'yes' : 'none'}`);
   }
 
   /** Cancel this worker. */
@@ -297,41 +297,34 @@ export class WorkerAgent {
 
     const _str = (v) => typeof v === 'string' ? v : (v ? JSON.stringify(v, null, 2) : '');
 
+    /** Try to build a structured result from a parsed JSON object. */
+    const _fromParsed = (parsed) => {
+      if (!parsed?.summary || !parsed?.status) return null;
+      return {
+        structured: true,
+        summary: String(parsed.summary || ''),
+        status: String(parsed.status || 'success'),
+        details: _str(parsed.details),
+        artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+        followUp: parsed.followUp ? String(parsed.followUp) : null,
+        toolsUsed: this._toolCallCount,
+        errors: this._errors,
+      };
+    };
+
     // Try to extract JSON from ```json ... ``` fences
     const fenceMatch = text.match(/```json\s*\n?([\s\S]*?)\n?\s*```/);
     if (fenceMatch) {
       try {
-        const parsed = JSON.parse(fenceMatch[1]);
-        if (parsed.summary && parsed.status) {
-          return {
-            structured: true,
-            summary: String(parsed.summary || ''),
-            status: String(parsed.status || 'success'),
-            details: _str(parsed.details),
-            artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-            followUp: parsed.followUp ? String(parsed.followUp) : null,
-            toolsUsed: this._toolCallCount,
-            errors: this._errors,
-          };
-        }
+        const result = _fromParsed(JSON.parse(fenceMatch[1]));
+        if (result) return result;
       } catch { /* fall through */ }
     }
 
     // Try raw JSON parse (no fences)
     try {
-      const parsed = JSON.parse(text);
-      if (parsed.summary && parsed.status) {
-        return {
-          structured: true,
-          summary: String(parsed.summary || ''),
-          status: String(parsed.status || 'success'),
-          details: _str(parsed.details),
-          artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
-          followUp: parsed.followUp ? String(parsed.followUp) : null,
-          toolsUsed: this._toolCallCount,
-          errors: this._errors,
-        };
-      }
+      const result = _fromParsed(JSON.parse(text));
+      if (result) return result;
     } catch { /* fall through */ }
 
     // Fallback: wrap raw text