@covibes/zeroshot 1.0.1 → 1.1.3

package/task-lib/commands/schedules.js

@@ -0,0 +1,98 @@
+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) {
+    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 * * * *"'));
+    return;
+  }
+
+  // Show daemon status
+  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();
+
+  // Sort by next run time
+  scheduleList.sort((a, b) => {
+    if (!a.nextRunAt) return 1;
+    if (!b.nextRunAt) return -1;
+    return new Date(a.nextRunAt) - new Date(b.nextRunAt);
+  });
+
+  console.log(chalk.bold('Scheduled Tasks:'));
+  console.log();
+
+  for (const schedule of scheduleList) {
+    const statusColor = schedule.enabled ? chalk.green : chalk.red;
+    const statusText = schedule.enabled ? '●' : '○';
+
+    console.log(`${statusColor(statusText)} ${chalk.cyan(schedule.id)}`);
+    console.log(chalk.dim(`  Prompt: ${schedule.prompt}`));
+
+    if (schedule.interval) {
+      const ms = schedule.interval;
+      let human;
+      if (ms >= 7 * 24 * 60 * 60 * 1000) human = `${ms / (7 * 24 * 60 * 60 * 1000)}w`;
+      else if (ms >= 24 * 60 * 60 * 1000) human = `${ms / (24 * 60 * 60 * 1000)}d`;
+      else if (ms >= 60 * 60 * 1000) human = `${ms / (60 * 60 * 1000)}h`;
+      else if (ms >= 60 * 1000) human = `${ms / (60 * 1000)}m`;
+      else human = `${ms / 1000}s`;
+      console.log(chalk.dim(`  Interval: every ${human}`));
+    }
+    if (schedule.cron) {
+      console.log(chalk.dim(`  Cron: ${schedule.cron}`));
+    }
+
+    if (schedule.nextRunAt) {
+      const nextRun = new Date(schedule.nextRunAt);
+      const now = new Date();
+      const diff = nextRun - now;
+
+      let timeUntil;
+      if (diff < 0) {
+        timeUntil = 'overdue';
+      } else if (diff < 60000) {
+        timeUntil = 'in < 1m';
+      } else if (diff < 3600000) {
+        timeUntil = `in ${Math.round(diff / 60000)}m`;
+      } else if (diff < 86400000) {
+        timeUntil = `in ${Math.round(diff / 3600000)}h`;
+      } else {
+        timeUntil = `in ${Math.round(diff / 86400000)}d`;
+      }
+
+      console.log(chalk.dim(`  Next run: ${nextRun.toISOString()} (${timeUntil})`));
+    }
+
+    if (schedule.lastRunAt) {
+      console.log(chalk.dim(`  Last run: ${schedule.lastRunAt}`));
+      if (schedule.lastTaskId) {
+        console.log(chalk.dim(`  Last task: ${schedule.lastTaskId}`));
+      }
+    }
+
+    if (schedule.verify) {
+      console.log(chalk.dim(`  Verify: enabled`));
+    }
+
+    console.log();
+  }
+
+  console.log(chalk.dim(`Total: ${scheduleList.length} schedule(s)`));
+}

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.blue,
+      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,10 @@
+import { homedir } from 'os';
+import { join } from 'path';
+
+export const TASKS_DIR = join(homedir(), '.claude-zeroshot');
+export const TASKS_FILE = join(TASKS_DIR, 'tasks.json');
+export const LOGS_DIR = join(TASKS_DIR, 'logs');
+export const SCHEDULES_FILE = join(TASKS_DIR, 'schedules.json');
+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/runner.js

@@ -0,0 +1,123 @@
+import { fork } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { LOGS_DIR, DEFAULT_MODEL } from './config.js';
+import { addTask, generateId, ensureDirs } from './store.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function spawnTask(prompt, options = {}) {
+  ensureDirs();
+
+  const id = generateId();
+  const logFile = join(LOGS_DIR, `${id}.log`);
+  const cwd = options.cwd || process.cwd();
+  const model = options.model || process.env.ANTHROPIC_MODEL || DEFAULT_MODEL;
+
+  // Build claude command args
+  // --print: non-interactive mode
+  // --dangerously-skip-permissions: background tasks can't prompt for approval (CRITICAL)
+  // --output-format: stream-json (default) for real-time, text for clean output, json for structured
+  const outputFormat = options.outputFormat || 'stream-json';
+  const args = ['--print', '--dangerously-skip-permissions', '--output-format', outputFormat];
+
+  // Only add streaming options for stream-json format
+  if (outputFormat === 'stream-json') {
+    args.push('--verbose');
+    // Include partial messages to get streaming updates before completion (required for stream-json format)
+    args.push('--include-partial-messages');
+  }
+
+  // Add JSON schema if provided (only works with --output-format json)
+  if (options.jsonSchema) {
+    if (outputFormat !== 'json') {
+      console.warn('Warning: --json-schema requires --output-format json, ignoring schema');
+    } else {
+      // CRITICAL: Must stringify schema object before passing to CLI (like zeroshot does)
+      const schemaString =
+        typeof options.jsonSchema === 'string'
+          ? options.jsonSchema
+          : JSON.stringify(options.jsonSchema);
+      args.push('--json-schema', schemaString);
+    }
+  }
+
+  if (options.resume) {
+    args.push('--resume', options.resume);
+  } else if (options.continue) {
+    args.push('--continue');
+  }
+
+  args.push(prompt);
+
+  const task = {
+    id,
+    prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
+    fullPrompt: prompt,
+    cwd,
+    status: 'running',
+    pid: null,
+    sessionId: options.resume || options.sessionId || null,
+    logFile,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    exitCode: null,
+    error: null,
+    // Schedule reference (if spawned by scheduler)
+    scheduleId: options.scheduleId || null,
+    // Attach support
+    socketPath: null,
+    attachable: false,
+  };
+
+  addTask(task);
+
+  // Fork a watcher process that will manage the claude process
+  const watcherConfig = {
+    outputFormat,
+    jsonSchema: options.jsonSchema || null,
+    silentJsonOutput: options.silentJsonOutput || false,
+    model,
+  };
+
+  // Use attachable watcher by default (unless explicitly disabled)
+  // Attachable watcher uses node-pty and creates a Unix socket for attach/detach
+  const useAttachable = options.attachable !== false;
+  const watcherScript = useAttachable
+    ? join(__dirname, 'attachable-watcher.js')
+    : join(__dirname, 'watcher.js');
+
+  const watcher = fork(
+    watcherScript,
+    [id, cwd, logFile, JSON.stringify(args), JSON.stringify(watcherConfig)],
+    {
+      detached: true,
+      stdio: 'ignore',
+    }
+  );
+
+  watcher.unref();
+
+  // Return task immediately - watcher will update PID async
+  return task;
+}
+
+export function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function killTask(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}