@covibes/zeroshot 1.0.1 → 1.0.2

package/task-lib/scheduler.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+/**
+ * Scheduler daemon - runs as background process
+ * Checks for due scheduled tasks and spawns them
+ */
+
+import { readFileSync, writeFileSync, existsSync, appendFileSync, unlinkSync } from 'fs';
+import { loadSchedules, updateSchedule } from './store.js';
+import { spawnTask } from './runner.js';
+import { SCHEDULER_PID_FILE, SCHEDULER_LOG } from './config.js';
+
+const CHECK_INTERVAL = 60000; // 60 seconds
+
+/**
+ * Parse human-readable interval to milliseconds
+ * Supports: 30s, 5m, 2h, 1d, 1w
+ */
+export function parseInterval(str) {
+  const match = str.match(/^(\d+)(s|m|h|d|w)$/i);
+  if (!match) return null;
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+
+  const multipliers = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+  };
+
+  return value * multipliers[unit];
+}
+
+/**
+ * Parse cron expression and get next run time
+ * Simple cron parser supporting: minute hour day month weekday
+ */
+export function getNextCronTime(cronExpr, fromDate = new Date()) {
+  const parts = cronExpr.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+
+  const [minute, hour] = parts;
+
+  // Simple implementation - just handle basic cases
+  // For full cron support, use cron-parser package
+  const next = new Date(fromDate);
+  next.setSeconds(0);
+  next.setMilliseconds(0);
+
+  // Handle simple cases
+  if (minute !== '*') {
+    const mins = minute.split(',').map((m) => parseInt(m, 10));
+    const currentMin = next.getMinutes();
+    const nextMin = mins.find((m) => m > currentMin) ?? mins[0];
+    if (nextMin <= currentMin) {
+      next.setHours(next.getHours() + 1);
+    }
+    next.setMinutes(nextMin);
+  }
+
+  if (hour !== '*') {
+    const hours = hour.split(',').map((h) => parseInt(h, 10));
+    const currentHour = next.getHours();
+    const nextHour = hours.find((h) => h > currentHour) ?? hours[0];
+    if (nextHour <= currentHour && minute === '*') {
+      next.setDate(next.getDate() + 1);
+    }
+    if (nextHour !== currentHour) {
+      next.setMinutes(minute === '*' ? 0 : parseInt(minute, 10));
+    }
+    next.setHours(nextHour);
+  }
+
+  // For complex cron expressions, fall back to 1 hour from now
+  // Full implementation would need cron-parser
+  if (next <= fromDate) {
+    next.setTime(fromDate.getTime() + 60 * 60 * 1000);
+  }
+
+  return next;
+}
+
+/**
+ * Calculate next run time for a schedule
+ */
+export function calculateNextRun(schedule) {
+  if (schedule.interval) {
+    return new Date(Date.now() + schedule.interval);
+  }
+  if (schedule.cron) {
+    return getNextCronTime(schedule.cron);
+  }
+  return null;
+}
+
+/**
+ * Log to scheduler log file
+ */
+function log(msg) {
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${msg}\n`;
+  appendFileSync(SCHEDULER_LOG, line);
+}
+
+/**
+ * Check and run due schedules
+ */
+function checkSchedules() {
+  const schedules = loadSchedules();
+  const now = new Date();
+
+  for (const schedule of Object.values(schedules)) {
+    if (!schedule.enabled) continue;
+
+    const nextRun = new Date(schedule.nextRunAt);
+    if (nextRun > now) continue;
+
+    // Schedule is due - spawn task
+    log(`Running scheduled task: ${schedule.id} - "${schedule.prompt.slice(0, 50)}..."`);
+
+    try {
+      const task = spawnTask(schedule.prompt, {
+        cwd: schedule.cwd,
+        scheduleId: schedule.id,
+      });
+
+      // Update schedule with next run time
+      const nextRunAt = calculateNextRun(schedule);
+      updateSchedule(schedule.id, {
+        lastRunAt: now.toISOString(),
+        lastTaskId: task.id,
+        nextRunAt: nextRunAt ? nextRunAt.toISOString() : null,
+      });
+
+      log(
+        `Spawned task ${task.id} for schedule ${schedule.id}, next run: ${nextRunAt?.toISOString() || 'none'}`
+      );
+    } catch (err) {
+      log(`Error spawning task for schedule ${schedule.id}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Start the scheduler daemon
+ */
+export function startDaemon() {
+  // Check if already running
+  if (existsSync(SCHEDULER_PID_FILE)) {
+    const existingPid = parseInt(readFileSync(SCHEDULER_PID_FILE, 'utf-8').trim(), 10);
+    try {
+      process.kill(existingPid, 0);
+      console.log(`Scheduler already running (PID: ${existingPid})`);
+      return false;
+    } catch {
+      // Process not running, clean up stale PID file
+      unlinkSync(SCHEDULER_PID_FILE);
+    }
+  }
+
+  // Write PID file
+  writeFileSync(SCHEDULER_PID_FILE, String(process.pid));
+
+  log(`Scheduler daemon started (PID: ${process.pid})`);
+  console.log(`Scheduler daemon started (PID: ${process.pid})`);
+
+  // Run check loop
+  const runLoop = async () => {
+    while (true) {
+      try {
+        await checkSchedules();
+      } catch (err) {
+        // Log error with full stack trace - scheduler errors are critical bugs
+        const errorMsg = `SCHEDULER ERROR: ${err.message}\nStack: ${err.stack}`;
+        log(errorMsg);
+        console.error(errorMsg);
+      }
+      await new Promise((r) => setTimeout(r, CHECK_INTERVAL));
+    }
+  };
+
+  // Handle shutdown
+  process.on('SIGTERM', () => {
+    log('Scheduler daemon stopping (SIGTERM)');
+    if (existsSync(SCHEDULER_PID_FILE)) {
+      unlinkSync(SCHEDULER_PID_FILE);
+    }
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    log('Scheduler daemon stopping (SIGINT)');
+    if (existsSync(SCHEDULER_PID_FILE)) {
+      unlinkSync(SCHEDULER_PID_FILE);
+    }
+    process.exit(0);
+  });
+
+  runLoop();
+  return true;
+}
+
+/**
+ * Stop the scheduler daemon
+ */
+export function stopDaemon() {
+  if (!existsSync(SCHEDULER_PID_FILE)) {
+    console.log('Scheduler is not running');
+    return false;
+  }
+
+  const pid = parseInt(readFileSync(SCHEDULER_PID_FILE, 'utf-8').trim(), 10);
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    unlinkSync(SCHEDULER_PID_FILE);
+    console.log(`Scheduler stopped (PID: ${pid})`);
+    log(`Scheduler daemon stopped by user (PID: ${pid})`);
+    return true;
+  } catch {
+    // Process not running, clean up
+    unlinkSync(SCHEDULER_PID_FILE);
+    console.log('Scheduler was not running (cleaned up stale PID file)');
+    return false;
+  }
+}
+
+/**
+ * Get daemon status
+ */
+export function getDaemonStatus() {
+  if (!existsSync(SCHEDULER_PID_FILE)) {
+    return { running: false, pid: null };
+  }
+
+  const pid = parseInt(readFileSync(SCHEDULER_PID_FILE, 'utf-8').trim(), 10);
+
+  try {
+    process.kill(pid, 0);
+    return { running: true, pid };
+  } catch {
+    return { running: false, pid: null, stale: true };
+  }
+}
+
+// If run directly, start daemon
+if (process.argv[1]?.endsWith('scheduler.js')) {
+  startDaemon();
+}

package/task-lib/store.js

@@ -0,0 +1,217 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { TASKS_DIR, TASKS_FILE, LOGS_DIR, SCHEDULES_FILE } from './config.js';
+import { generateName } from './name-generator.js';
+import lockfile from 'proper-lockfile';
+
+// Lock options for sync API (no retries allowed)
+const LOCK_OPTIONS = {
+  stale: 30000, // Consider lock stale after 30s
+};
+
+// Retry wrapper for sync lock acquisition
+function lockWithRetry(file, options, maxRetries = 100, delayMs = 100) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return lockfile.lockSync(file, options);
+    } catch (err) {
+      if (err.code === 'ELOCKED' && i < maxRetries - 1) {
+        // File is locked, wait and retry
+        const start = Date.now();
+        while (Date.now() - start < delayMs) {
+          // Busy wait (sync)
+        }
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire lock after ${maxRetries} retries`);
+}
+
+export function ensureDirs() {
+  if (!existsSync(TASKS_DIR)) mkdirSync(TASKS_DIR, { recursive: true });
+  if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
+}
+
+/**
+ * Read tasks.json (no locking - use for read-only operations)
+ */
+export function loadTasks() {
+  ensureDirs();
+  if (!existsSync(TASKS_FILE)) return {};
+  const content = readFileSync(TASKS_FILE, 'utf-8');
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `CRITICAL: tasks.json is corrupted and cannot be parsed. Error: ${error.message}. Content: ${content.slice(0, 200)}...`
+    );
+  }
+}
+
+/**
+ * Write tasks.json (no locking - internal use only)
+ */
+export function saveTasks(tasks) {
+  ensureDirs();
+  writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
+}
+
+/**
+ * Atomic read-modify-write with file locking
+ * @param {Function} modifier - Function that receives tasks object and returns modified tasks
+ * @returns {any} - Return value from modifier function
+ */
+export function withTasksLock(modifier) {
+  ensureDirs();
+
+  // Create file if it doesn't exist (needed for locking)
+  if (!existsSync(TASKS_FILE)) {
+    writeFileSync(TASKS_FILE, '{}');
+  }
+
+  let release;
+  try {
+    // Acquire lock (blocks until available)
+    release = lockWithRetry(TASKS_FILE, LOCK_OPTIONS);
+
+    // Read current state
+    const content = readFileSync(TASKS_FILE, 'utf-8');
+    let tasks;
+    try {
+      tasks = JSON.parse(content);
+    } catch (error) {
+      throw new Error(`CRITICAL: tasks.json is corrupted. Error: ${error.message}`);
+    }
+
+    // Apply modification
+    const result = modifier(tasks);
+
+    // Write back
+    writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
+
+    return result;
+  } finally {
+    if (release) {
+      release();
+    }
+  }
+}
+
+export function getTask(id) {
+  const tasks = loadTasks();
+  return tasks[id];
+}
+
+export function updateTask(id, updates) {
+  return withTasksLock((tasks) => {
+    if (!tasks[id]) return null;
+    tasks[id] = {
+      ...tasks[id],
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+    return tasks[id];
+  });
+}
+
+export function addTask(task) {
+  return withTasksLock((tasks) => {
+    tasks[task.id] = task;
+    return task;
+  });
+}
+
+export function removeTask(id) {
+  withTasksLock((tasks) => {
+    delete tasks[id];
+  });
+}
+
+export function generateId() {
+  return generateName('task');
+}
+
+export function generateScheduleId() {
+  return generateName('sched');
+}
+
+// Schedule management - same pattern with locking
+
+function withSchedulesLock(modifier) {
+  ensureDirs();
+
+  if (!existsSync(SCHEDULES_FILE)) {
+    writeFileSync(SCHEDULES_FILE, '{}');
+  }
+
+  let release;
+  try {
+    release = lockWithRetry(SCHEDULES_FILE, LOCK_OPTIONS);
+
+    const content = readFileSync(SCHEDULES_FILE, 'utf-8');
+    let schedules;
+    try {
+      schedules = JSON.parse(content);
+    } catch (error) {
+      throw new Error(`CRITICAL: schedules.json is corrupted. Error: ${error.message}`);
+    }
+
+    const result = modifier(schedules);
+    writeFileSync(SCHEDULES_FILE, JSON.stringify(schedules, null, 2));
+
+    return result;
+  } finally {
+    if (release) {
+      release();
+    }
+  }
+}
+
+export function loadSchedules() {
+  ensureDirs();
+  if (!existsSync(SCHEDULES_FILE)) return {};
+  const content = readFileSync(SCHEDULES_FILE, 'utf-8');
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `CRITICAL: schedules.json is corrupted and cannot be parsed. Error: ${error.message}. Content: ${content.slice(0, 200)}...`
+    );
+  }
+}
+
+export function saveSchedules(schedules) {
+  ensureDirs();
+  writeFileSync(SCHEDULES_FILE, JSON.stringify(schedules, null, 2));
+}
+
+export function getSchedule(id) {
+  const schedules = loadSchedules();
+  return schedules[id];
+}
+
+export function addSchedule(schedule) {
+  return withSchedulesLock((schedules) => {
+    schedules[schedule.id] = schedule;
+    return schedule;
+  });
+}
+
+export function updateSchedule(id, updates) {
+  return withSchedulesLock((schedules) => {
+    if (!schedules[id]) return null;
+    schedules[id] = {
+      ...schedules[id],
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+    return schedules[id];
+  });
+}
+
+export function removeSchedule(id) {
+  withSchedulesLock((schedules) => {
+    delete schedules[id];
+  });
+}

package/task-lib/tui/formatters.js

@@ -0,0 +1,166 @@
+/**
+ * Formatting utilities for TUI display
+ */
+
+/**
+ * Format timestamp as human-readable relative time
+ * @param {number} ms - Milliseconds
+ * @returns {string} Formatted time (e.g., "2m 30s", "1h 15m")
+ */
+function formatTimestamp(ms) {
+  if (!ms || ms < 0) return '-';
+
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+/**
+ * Format bytes as human-readable size
+ * @param {number} bytes - Bytes
+ * @returns {string} Formatted size (e.g., "1.5 MB", "512 KB")
+ */
+function formatBytes(bytes) {
+  if (!bytes || bytes === 0) return '0 B';
+  if (bytes < 0) return '-';
+
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+
+/**
+ * Format CPU percentage
+ * @param {number} cpu - CPU percentage (0-100)
+ * @returns {string} Formatted CPU (e.g., "23.5%", "0.1%")
+ */
+function formatCPU(cpu) {
+  if (cpu === undefined || cpu === null || cpu < 0) return '0.0%';
+  return `${cpu.toFixed(1)}%`;
+}
+
+/**
+ * Get state icon and color
+ * @param {string} state - Task state (pending, running, completed, failed, etc.)
+ * @returns {string} Colored icon
+ */
+function stateIcon(state) {
+  const icons = {
+    pending: '○',
+    running: '●',
+    completed: '✓',
+    failed: '✗',
+    killed: '⊗',
+    unknown: '?',
+  };
+
+  const colors = {
+    pending: 'gray',
+    running: 'cyan',
+    completed: 'green',
+    failed: 'red',
+    killed: 'red',
+    unknown: 'gray',
+  };
+
+  const icon = icons[state] || icons.unknown;
+  const color = colors[state] || colors.unknown;
+
+  return `{${color}-fg}${icon}{/}`;
+}
+
+/**
+ * Truncate string to max length with ellipsis
+ * @param {string} str - String to truncate
+ * @param {number} maxLen - Maximum length
+ * @returns {string} Truncated string
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 1) + '…';
+}
+
+/**
+ * Parse event type from Claude JSON stream
+ * @param {string} line - Raw log line
+ * @returns {object|null} Parsed event with type, text, toolName, error
+ */
+function parseEvent(line) {
+  let trimmed = line.trim();
+
+  // Strip timestamp prefix if present: [1234567890]{...} -> {...}
+  const timestampMatch = trimmed.match(/^\[(\d+)\](.*)$/);
+  let timestamp = Date.now();
+  if (timestampMatch) {
+    timestamp = parseInt(timestampMatch[1]);
+    trimmed = timestampMatch[2];
+  }
+
+  // Keep non-JSON lines as-is
+  if (!trimmed.startsWith('{')) {
+    return trimmed ? { type: 'raw', text: trimmed, timestamp } : null;
+  }
+
+  // Parse JSON events
+  try {
+    const event = JSON.parse(trimmed);
+
+    // Text delta
+    if (event.type === 'stream_event' && event.event?.type === 'content_block_delta') {
+      return {
+        type: 'text',
+        text: event.event?.delta?.text || '',
+        timestamp,
+      };
+    }
+    // Tool use
+    else if (event.type === 'stream_event' && event.event?.type === 'content_block_start') {
+      const block = event.event?.content_block;
+      if (block?.type === 'tool_use' && block?.name) {
+        return {
+          type: 'tool',
+          toolName: block.name,
+          timestamp,
+        };
+      }
+    }
+    // Assistant message
+    else if (event.type === 'assistant' && event.message?.content) {
+      let text = '';
+      for (const content of event.message.content) {
+        if (content.type === 'text') {
+          text += content.text;
+        }
+      }
+      return text ? { type: 'text', text, timestamp } : null;
+    }
+    // Error
+    else if (event.type === 'result' && event.is_error) {
+      return {
+        type: 'error',
+        text: event.result || 'Unknown error',
+        timestamp,
+      };
+    }
+  } catch {
+    // Parse error - skip
+  }
+
+  return null;
+}
+
+export { formatTimestamp, formatBytes, formatCPU, stateIcon, truncate, parseEvent };