@covibes/zeroshot 5.3.0 → 5.4.1

package/task-lib/scheduler.js

@@ -1,252 +0,0 @@
-#!/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
- */
-async 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 = await 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

@@ -1,230 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync } 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';
-
-// Stale lock timeout - 5 seconds is plenty for JSON read/write
-const LOCK_STALE_MS = 5000;
-
-// Lock options with async retry support
-const LOCK_OPTIONS = {
-  stale: LOCK_STALE_MS,
-  retries: {
-    retries: 20,
-    minTimeout: 100,
-    maxTimeout: 200,
-    randomize: true,
-  },
-};
-
-/**
- * Remove lock file if it's stale (older than LOCK_STALE_MS)
- */
-function cleanStaleLock(filePath) {
-  const lockPath = filePath + '.lock';
-  try {
-    if (existsSync(lockPath)) {
-      const age = Date.now() - statSync(lockPath).mtimeMs;
-      if (age > LOCK_STALE_MS) {
-        unlinkSync(lockPath);
-      }
-    }
-  } catch {
-    // Ignore - another process may have cleaned it
-  }
-}
-
-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 {Promise<any>} - Return value from modifier function
- */
-export async function withTasksLock(modifier) {
-  ensureDirs();
-
-  // Create file if it doesn't exist (needed for locking)
-  if (!existsSync(TASKS_FILE)) {
-    writeFileSync(TASKS_FILE, '{}');
-  }
-
-  let release;
-  try {
-    // Clean stale locks from crashed processes
-    cleanStaleLock(TASKS_FILE);
-
-    // Acquire lock with async API (proper retries without CPU spin-wait)
-    release = await lockfile.lock(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) {
-      await 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 async function removeTask(id) {
-  await withTasksLock((tasks) => {
-    delete tasks[id];
-  });
-}
-
-export function generateId() {
-  return generateName('task');
-}
-
-export function generateScheduleId() {
-  return generateName('sched');
-}
-
-// Schedule management - same pattern with locking
-
-async function withSchedulesLock(modifier) {
-  ensureDirs();
-
-  if (!existsSync(SCHEDULES_FILE)) {
-    writeFileSync(SCHEDULES_FILE, '{}');
-  }
-
-  let release;
-  try {
-    // Clean stale locks from crashed processes
-    cleanStaleLock(SCHEDULES_FILE);
-
-    // Acquire lock with async API (proper retries without CPU spin-wait)
-    release = await lockfile.lock(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) {
-      await 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 async function removeSchedule(id) {
-  await withSchedulesLock((schedules) => {
-    delete schedules[id];
-  });
-}

package/task-lib/tui/formatters.js

@@ -1,166 +0,0 @@
-/**
- * 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 };