@the-open-engine/zeroshot 5.4.0

package/task-lib/commands/scheduler-cmd.js

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import { fork } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getDaemonStatus, stopDaemon } from '../scheduler.js';
+import { SCHEDULER_LOG } from '../config.js';
+import { existsSync, readFileSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function schedulerCommand(action) {
+  switch (action) {
+    case 'start':
+      startScheduler();
+      break;
+    case 'stop':
+      stopScheduler();
+      break;
+    case 'status':
+      showStatus();
+      break;
+    case 'logs':
+      showLogs();
+      break;
+    default:
+      console.log(chalk.red(`Unknown action: ${action}`));
+      console.log(chalk.dim('Available actions: start, stop, status, logs'));
+      process.exit(1);
+  }
+}
+
+function startScheduler() {
+  const status = getDaemonStatus();
+
+  if (status.running) {
+    console.log(chalk.yellow(`Scheduler already running (PID: ${status.pid})`));
+    return;
+  }
+
+  if (status.stale) {
+    console.log(chalk.dim('Cleaning up stale PID file...'));
+  }
+
+  console.log(chalk.dim('Starting scheduler daemon...'));
+
+  const scheduler = fork(join(__dirname, '..', 'scheduler.js'), [], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  scheduler.unref();
+
+  // Give it a moment to start
+  setTimeout(() => {
+    const newStatus = getDaemonStatus();
+    if (newStatus.running) {
+      console.log(chalk.green(`✓ Scheduler started (PID: ${newStatus.pid})`));
+    } else {
+      console.log(chalk.red('Failed to start scheduler. Check logs:'));
+      console.log(chalk.dim(`  zeroshot scheduler logs`));
+    }
+  }, 500);
+}
+
+function stopScheduler() {
+  const stopped = stopDaemon();
+  if (!stopped) {
+    process.exit(1);
+  }
+}
+
+function showStatus() {
+  const status = getDaemonStatus();
+
+  if (status.running) {
+    console.log(chalk.green(`Scheduler: running`));
+    console.log(chalk.dim(`  PID: ${status.pid}`));
+    console.log(chalk.dim(`  Log: ${SCHEDULER_LOG}`));
+  } else if (status.stale) {
+    console.log(chalk.yellow('Scheduler: not running (stale PID file)'));
+    console.log(chalk.dim('  Run: zeroshot scheduler start'));
+  } else {
+    console.log(chalk.red('Scheduler: not running'));
+    console.log(chalk.dim('  Run: zeroshot scheduler start'));
+  }
+}
+
+function showLogs() {
+  if (!existsSync(SCHEDULER_LOG)) {
+    console.log(chalk.dim('No scheduler logs found.'));
+    return;
+  }
+
+  const content = readFileSync(SCHEDULER_LOG, 'utf-8');
+  const lines = content.split('\n').slice(-50); // Last 50 lines
+  console.log(lines.join('\n'));
+}

package/task-lib/commands/schedules.js

@@ -0,0 +1,148 @@
+import chalk from 'chalk';
+import { loadSchedules } from '../store.js';
+import { getDaemonStatus } from '../scheduler.js';
+
+export function listSchedules(_options = {}) {
+  const schedules = loadSchedules();
+  const scheduleList = Object.values(schedules);
+
+  // Check daemon status
+  const daemonStatus = getDaemonStatus();
+
+  if (scheduleList.length === 0) {
+    printNoSchedules();
+    return;
+  }
+
+  printDaemonStatus(daemonStatus);
+
+  // Sort by next run time
+  sortSchedulesByNextRun(scheduleList);
+
+  printScheduleHeader();
+
+  for (const schedule of scheduleList) {
+    printSchedule(schedule);
+  }
+
+  console.log(chalk.dim(`Total: ${scheduleList.length} schedule(s)`));
+}
+
+function printNoSchedules() {
+  console.log(chalk.dim('No schedules found.'));
+  console.log(chalk.dim('\nCreate a schedule:'));
+  console.log(chalk.dim('  zeroshot schedule "your prompt" --every 1h'));
+  console.log(chalk.dim('  zeroshot schedule "your prompt" --cron "0 * * * *"'));
+}
+
+function printDaemonStatus(daemonStatus) {
+  if (daemonStatus.running) {
+    console.log(chalk.green(`Scheduler: running (PID: ${daemonStatus.pid})`));
+  } else if (daemonStatus.stale) {
+    console.log(chalk.yellow('Scheduler: not running (stale PID file)'));
+  } else {
+    console.log(chalk.red('Scheduler: not running'));
+    console.log(chalk.dim('  Run: zeroshot scheduler start'));
+  }
+  console.log();
+}
+
+function sortSchedulesByNextRun(scheduleList) {
+  scheduleList.sort((a, b) => {
+    if (!a.nextRunAt) return 1;
+    if (!b.nextRunAt) return -1;
+    return new Date(a.nextRunAt) - new Date(b.nextRunAt);
+  });
+}
+
+function printScheduleHeader() {
+  console.log(chalk.bold('Scheduled Tasks:'));
+  console.log();
+}
+
+function printSchedule(schedule) {
+  printScheduleHeaderLine(schedule);
+  printSchedulePrompt(schedule);
+  printScheduleInterval(schedule);
+  printScheduleCron(schedule);
+  printScheduleNextRun(schedule);
+  printScheduleLastRun(schedule);
+  printScheduleVerify(schedule);
+  console.log();
+}
+
+function printScheduleHeaderLine(schedule) {
+  const statusColor = schedule.enabled ? chalk.green : chalk.red;
+  const statusText = schedule.enabled ? '●' : '○';
+  console.log(`${statusColor(statusText)} ${chalk.cyan(schedule.id)}`);
+}
+
+function printSchedulePrompt(schedule) {
+  console.log(chalk.dim(`  Prompt: ${schedule.prompt}`));
+}
+
+function printScheduleInterval(schedule) {
+  if (!schedule.interval) {
+    return;
+  }
+  const human = formatInterval(schedule.interval);
+  console.log(chalk.dim(`  Interval: every ${human}`));
+}
+
+function printScheduleCron(schedule) {
+  if (schedule.cron) {
+    console.log(chalk.dim(`  Cron: ${schedule.cron}`));
+  }
+}
+
+function printScheduleNextRun(schedule) {
+  if (!schedule.nextRunAt) {
+    return;
+  }
+  const nextRun = new Date(schedule.nextRunAt);
+  const timeUntil = formatTimeUntil(nextRun);
+  console.log(chalk.dim(`  Next run: ${nextRun.toISOString()} (${timeUntil})`));
+}
+
+function printScheduleLastRun(schedule) {
+  if (!schedule.lastRunAt) {
+    return;
+  }
+  console.log(chalk.dim(`  Last run: ${schedule.lastRunAt}`));
+  if (schedule.lastTaskId) {
+    console.log(chalk.dim(`  Last task: ${schedule.lastTaskId}`));
+  }
+}
+
+function printScheduleVerify(schedule) {
+  if (schedule.verify) {
+    console.log(chalk.dim(`  Verify: enabled`));
+  }
+}
+
+function formatInterval(ms) {
+  if (ms >= 7 * 24 * 60 * 60 * 1000) return `${ms / (7 * 24 * 60 * 60 * 1000)}w`;
+  if (ms >= 24 * 60 * 60 * 1000) return `${ms / (24 * 60 * 60 * 1000)}d`;
+  if (ms >= 60 * 60 * 1000) return `${ms / (60 * 60 * 1000)}h`;
+  if (ms >= 60 * 1000) return `${ms / (60 * 1000)}m`;
+  return `${ms / 1000}s`;
+}
+
+function formatTimeUntil(nextRun) {
+  const now = new Date();
+  const diff = nextRun - now;
+
+  if (diff < 0) {
+    return 'overdue';
+  }
+  if (diff < 60000) {
+    return 'in < 1m';
+  }
+  if (diff < 3600000) {
+    return `in ${Math.round(diff / 60000)}m`;
+  }
+  if (diff < 86400000) {
+    return `in ${Math.round(diff / 3600000)}h`;
+  }
+  return `in ${Math.round(diff / 86400000)}d`;
+}

package/task-lib/commands/status.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import { getTask } from '../store.js';
+import { isProcessRunning } from '../runner.js';
+
+export function showStatus(taskId) {
+  const task = getTask(taskId);
+
+  if (!task) {
+    console.log(chalk.red(`Task not found: ${taskId}`));
+    process.exit(1);
+  }
+
+  // Verify running status
+  let status = task.status;
+  if (status === 'running' && !isProcessRunning(task.pid)) {
+    status = 'stale (process died)';
+  }
+
+  const statusColor =
+    {
+      running: chalk.green,
+      completed: chalk.green,
+      failed: chalk.red,
+    }[task.status] || chalk.yellow;
+
+  console.log(chalk.bold(`\nTask: ${task.id}\n`));
+  console.log(`${chalk.dim('Status:')}     ${statusColor(status)}`);
+  console.log(`${chalk.dim('Created:')}    ${task.createdAt}`);
+  console.log(`${chalk.dim('Updated:')}    ${task.updatedAt}`);
+  console.log(`${chalk.dim('CWD:')}        ${task.cwd}`);
+  console.log(`${chalk.dim('PID:')}        ${task.pid || 'N/A'}`);
+  console.log(`${chalk.dim('Exit Code:')}  ${task.exitCode ?? 'N/A'}`);
+  console.log(`${chalk.dim('Session:')}    ${task.sessionId || 'N/A'}`);
+  console.log(`${chalk.dim('Log File:')}   ${task.logFile}`);
+
+  console.log(`\n${chalk.dim('Prompt:')}`);
+  console.log(task.fullPrompt || task.prompt);
+
+  if (task.error) {
+    console.log(`\n${chalk.red('Error:')} ${task.error}`);
+  }
+
+  console.log();
+}

package/task-lib/commands/unschedule.js

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+import { getSchedule, removeSchedule } from '../store.js';
+
+export function deleteSchedule(scheduleId) {
+  const schedule = getSchedule(scheduleId);
+
+  if (!schedule) {
+    console.log(chalk.red(`Schedule not found: ${scheduleId}`));
+    process.exit(1);
+  }
+
+  removeSchedule(scheduleId);
+
+  console.log(chalk.green(`✓ Schedule removed: ${chalk.cyan(scheduleId)}`));
+  console.log(chalk.dim(`  Prompt: ${schedule.prompt}`));
+}

package/task-lib/completion.js

@@ -0,0 +1,9 @@
+/**
+ * Shell completion setup for ct
+ * Placeholder - completion not yet implemented
+ */
+
+export function setupCompletion() {
+  // TODO: Implement shell completion
+  // For now, this is a no-op
+}

package/task-lib/config.js

@@ -0,0 +1,11 @@
+import { join } from 'path';
+import { homedir } from 'os';
+
+const HOME_DIR =
+  process.env.ZEROSHOT_HOME || process.env.HOME || process.env.USERPROFILE || homedir();
+
+export const TASKS_DIR = join(HOME_DIR, '.claude-zeroshot');
+export const LOGS_DIR = join(TASKS_DIR, 'logs');
+export const SCHEDULER_PID_FILE = join(TASKS_DIR, 'scheduler.pid');
+export const SCHEDULER_LOG = join(TASKS_DIR, 'scheduler.log');
+export const DEFAULT_MODEL = 'sonnet';

package/task-lib/name-generator.js

@@ -0,0 +1,230 @@
+/**
+ * Human-readable name generator (like Weights & Biases)
+ * Generates names like "wandering-forest-42" or "bright-star-17"
+ *
+ * No prefix - short forms used everywhere for simplicity
+ */
+
+const ADJECTIVES = [
+  // Colors
+  'amber',
+  'azure',
+  'crimson',
+  'emerald',
+  'golden',
+  'indigo',
+  'jade',
+  'ruby',
+  'sapphire',
+  'silver',
+  'violet',
+  'bronze',
+  'coral',
+  'ivory',
+  'pearl',
+  'platinum',
+  'scarlet',
+  'cobalt',
+  'copper',
+  'obsidian',
+  'onyx',
+  'opal',
+  'topaz',
+  'turquoise',
+  // Nature
+  'wandering',
+  'bright',
+  'silent',
+  'ancient',
+  'swift',
+  'noble',
+  'bold',
+  'wild',
+  'gentle',
+  'hidden',
+  'fierce',
+  'calm',
+  'frozen',
+  'misty',
+  'stormy',
+  'sunny',
+  // Cosmic
+  'cosmic',
+  'crystal',
+  'electric',
+  'lunar',
+  'solar',
+  'stellar',
+  'astral',
+  'orbital',
+  'mystic',
+  'quantum',
+  'radiant',
+  'twilight',
+  'vivid',
+  'zen',
+  'infinite',
+  'eternal',
+  // Tech/Abstract
+  'clever',
+  'rapid',
+  'steady',
+  'agile',
+  'nimble',
+  'keen',
+  'sharp',
+  'quick',
+  'prime',
+  'binary',
+  'neural',
+  'atomic',
+  'sonic',
+  'hyper',
+  'mega',
+  'ultra',
+  // Descriptive
+  'blazing',
+  'gleaming',
+  'glowing',
+  'shining',
+  'burning',
+  'flaming',
+  'sparkling',
+  'dazzling',
+  'roaring',
+  'rushing',
+  'soaring',
+  'flying',
+  'rising',
+  'falling',
+  'spinning',
+  'dancing',
+];
+
+const NOUNS = [
+  // Nature
+  'forest',
+  'river',
+  'mountain',
+  'ocean',
+  'thunder',
+  'canyon',
+  'summit',
+  'valley',
+  'cascade',
+  'glacier',
+  'volcano',
+  'desert',
+  'meadow',
+  'tundra',
+  'jungle',
+  'reef',
+  // Space
+  'star',
+  'comet',
+  'nebula',
+  'galaxy',
+  'pulsar',
+  'quasar',
+  'aurora',
+  'eclipse',
+  'meteor',
+  'nova',
+  'cosmos',
+  'orbit',
+  'void',
+  'horizon',
+  'zenith',
+  'equinox',
+  // Mythical
+  'phoenix',
+  'dragon',
+  'griffin',
+  'sphinx',
+  'hydra',
+  'kraken',
+  'titan',
+  'atlas',
+  'oracle',
+  'rune',
+  'sigil',
+  'glyph',
+  'totem',
+  'aegis',
+  'aether',
+  'flux',
+  // Animals
+  'falcon',
+  'eagle',
+  'wolf',
+  'bear',
+  'tiger',
+  'hawk',
+  'lion',
+  'panther',
+  'raven',
+  'serpent',
+  'shark',
+  'owl',
+  'fox',
+  'lynx',
+  'viper',
+  'condor',
+  // Architecture
+  'citadel',
+  'temple',
+  'spire',
+  'tower',
+  'fortress',
+  'bastion',
+  'vault',
+  'sanctum',
+  'beacon',
+  'arch',
+  'bridge',
+  'gate',
+  'hall',
+  'keep',
+  'dome',
+  'obelisk',
+  // Abstract
+  'cipher',
+  'echo',
+  'nexus',
+  'prism',
+  'relic',
+  'vertex',
+  'vortex',
+  'pulse',
+  'surge',
+  'spark',
+  'flame',
+  'storm',
+  'wave',
+  'drift',
+  'shift',
+  'core',
+];
+
+// 96 adjectives × 96 nouns × 100 numbers = 921,600 combinations
+
+/**
+ * Generate a human-readable name
+ * @param {string} _prefix - DEPRECATED: Ignored for backwards compat, short form always used
+ * @returns {string} Human-readable name (e.g., 'wandering-forest-42')
+ */
+export function generateName(_prefix = '') {
+  const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+  const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+  const number = Math.floor(Math.random() * 100);
+
+  return `${adjective}-${noun}-${number}`;
+}
+
+/**
+ * Generate a short unique suffix (for collision prevention)
+ * @returns {string} Short random suffix (e.g., 'a3f9')
+ */
+export function generateSuffix() {
+  return Math.random().toString(36).slice(2, 6);
+}

package/task-lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/task-lib/provider-helper-runtime.js

@@ -0,0 +1,29 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+let helper;
+try {
+  helper = require('../lib/agent-cli-provider');
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  throw new Error(
+    `Provider helper build missing. Run npm run build:agent-cli-provider. ${message}`
+  );
+}
+
+export const {
+  NO_MESSAGES_RETURNED,
+  STREAMING_MODE_ERROR,
+  buildProviderCommand,
+  classifyProviderError,
+  detectProviderFatalError,
+  detectProviderStreamingModeError,
+  getProviderAdapter,
+  listProviderAdapters,
+  parseProviderChunk,
+  prepareSingleAgentProviderCommand,
+  recoverProviderStructuredOutput,
+  resolveModelSpec,
+  supportsProviderStructuredOutputRecovery,
+} = helper;