@covibes/zeroshot 5.2.1 → 5.4.0

package/task-lib/commands/schedules.js

@@ -10,14 +10,32 @@ export function listSchedules(_options = {}) {
   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 * * * *"'));
+    printNoSchedules();
     return;
   }
 
-  // Show daemon status
+  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) {
@@ -27,72 +45,104 @@ export function listSchedules(_options = {}) {
     console.log(chalk.dim('  Run: zeroshot scheduler start'));
   }
   console.log();
+}
 
-  // Sort by next run time
+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();
+}
 
-  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();
+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}`));
+}
 
-  console.log(chalk.dim(`Total: ${scheduleList.length} schedule(s)`));
+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/config.js

@@ -2,9 +2,7 @@ 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/runner.js

@@ -1,56 +1,133 @@
 import { fork } from 'child_process';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { LOGS_DIR, DEFAULT_MODEL } from './config.js';
+import { LOGS_DIR } from './config.js';
 import { addTask, generateId, ensureDirs } from './store.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { loadSettings } = require('../lib/settings.js');
+const { normalizeProviderName } = require('../lib/provider-names');
+const { getProvider } = require('../src/providers');
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-export function spawnTask(prompt, options = {}) {
+export async 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');
+
+  const settings = loadSettings();
+  const { providerName, provider, providerSettings, levelOverrides } = resolveProviderContext(
+    options,
+    settings
+  );
+
+  const outputFormat = resolveOutputFormat(options);
+  const jsonSchema = resolveJsonSchema(options, outputFormat);
+  const modelSpec = resolveModelSpec(options, provider, providerSettings, levelOverrides);
+
+  const cliFeatures = await provider.getCliFeatures();
+  const commandSpec = provider.buildCommand(prompt, {
+    modelSpec,
+    outputFormat,
+    jsonSchema,
+    cwd,
+    autoApprove: true,
+    cliFeatures,
+  });
+
+  const finalArgs = resolveFinalArgs(commandSpec, providerName, options);
+  const task = buildTaskRecord({
+    id,
+    prompt,
+    cwd,
+    options,
+    logFile,
+    providerName,
+    modelSpec,
+  });
+
+  addTask(task);
+
+  const watcherConfig = buildWatcherConfig(
+    outputFormat,
+    jsonSchema,
+    options,
+    providerName,
+    commandSpec
+  );
+  const watcherScript = resolveWatcherScript(options);
+  spawnWatcher({
+    watcherScript,
+    id,
+    cwd,
+    logFile,
+    finalArgs,
+    watcherConfig,
+  });
+
+  return task;
+}
+
+function resolveProviderContext(options, settings) {
+  const providerName = normalizeProviderName(
+    options.provider || settings.defaultProvider || 'claude'
+  );
+  const provider = getProvider(providerName);
+  const providerSettings = settings.providerSettings?.[providerName] || {};
+  const levelOverrides = providerSettings.levelOverrides || {};
+  return { providerName, provider, providerSettings, levelOverrides };
+}
+
+function resolveOutputFormat(options) {
+  return options.outputFormat || 'stream-json';
+}
+
+function resolveJsonSchema(options, outputFormat) {
+  let jsonSchema = options.jsonSchema || null;
+  if (jsonSchema && outputFormat !== 'json') {
+    console.warn('Warning: --json-schema requires --output-format json, ignoring schema');
+    jsonSchema = null;
   }
+  return jsonSchema;
+}
 
-  // 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);
-    }
+function resolveModelSpec(options, provider, providerSettings, levelOverrides) {
+  if (options.model) {
+    return {
+      model: options.model,
+      reasoningEffort: options.reasoningEffort,
+    };
   }
 
-  if (options.resume) {
-    args.push('--resume', options.resume);
-  } else if (options.continue) {
-    args.push('--continue');
+  const level = options.modelLevel || providerSettings.defaultLevel || provider.getDefaultLevel();
+  let modelSpec = provider.resolveModelSpec(level, levelOverrides);
+  if (options.reasoningEffort) {
+    modelSpec = { ...modelSpec, reasoningEffort: options.reasoningEffort };
   }
+  return modelSpec;
+}
 
-  args.push(prompt);
+function resolveFinalArgs(commandSpec, providerName, options) {
+  const finalArgs = [...commandSpec.args];
+  if (providerName === 'claude') {
+    const promptIndex = finalArgs.length - 1;
+    if (options.resume) {
+      finalArgs.splice(promptIndex, 0, '--resume', options.resume);
+    } else if (options.continue) {
+      finalArgs.splice(promptIndex, 0, '--continue');
+    }
+  } else if (options.resume || options.continue) {
+    console.warn('Warning: resume/continue is only supported for Claude CLI; ignoring.');
+  }
+  return finalArgs;
+}
 
-  const task = {
+function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, modelSpec }) {
+  return {
     id,
     prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
     fullPrompt: prompt,
@@ -63,33 +140,36 @@ export function spawnTask(prompt, options = {}) {
     updatedAt: new Date().toISOString(),
     exitCode: null,
     error: null,
+    provider: providerName,
+    model: modelSpec?.model || 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 = {
+function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, commandSpec) {
+  return {
     outputFormat,
-    jsonSchema: options.jsonSchema || null,
+    jsonSchema,
     silentJsonOutput: options.silentJsonOutput || false,
-    model,
+    provider: providerName,
+    command: commandSpec.binary,
+    env: commandSpec.env || {},
   };
+}
 
-  // 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');
+function resolveWatcherScript(options) {
+  const useAttachable = options.attachable !== false && !options.jsonSchema;
+  return useAttachable ? join(__dirname, 'attachable-watcher.js') : join(__dirname, 'watcher.js');
+}
 
+function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfig }) {
   const watcher = fork(
     watcherScript,
-    [id, cwd, logFile, JSON.stringify(args), JSON.stringify(watcherConfig)],
+    [id, cwd, logFile, JSON.stringify(finalArgs), JSON.stringify(watcherConfig)],
     {
       detached: true,
       stdio: 'ignore',
@@ -97,9 +177,7 @@ export function spawnTask(prompt, options = {}) {
   );
 
   watcher.unref();
-
-  // Return task immediately - watcher will update PID async
-  return task;
+  watcher.disconnect(); // Close IPC channel so parent can exit
 }
 
 export function isProcessRunning(pid) {

package/task-lib/scheduler.js

@@ -17,7 +17,7 @@ const CHECK_INTERVAL = 60000; // 60 seconds
  * Supports: 30s, 5m, 2h, 1d, 1w
  */
 export function parseInterval(str) {
-  const match = str.match(/^(\d+)(s|m|h|d|w)$/i);
+  const match = str.match(/^(\d+)([smhdw])$/i);
   if (!match) return null;
 
   const value = parseInt(match[1], 10);
@@ -108,7 +108,7 @@ function log(msg) {
 /**
  * Check and run due schedules
  */
-function checkSchedules() {
+async function checkSchedules() {
   const schedules = loadSchedules();
   const now = new Date();
 
@@ -122,7 +122,7 @@ function checkSchedules() {
     log(`Running scheduled task: ${schedule.id} - "${schedule.prompt.slice(0, 50)}..."`);
 
     try {
-      const task = spawnTask(schedule.prompt, {
+      const task = await spawnTask(schedule.prompt, {
         cwd: schedule.cwd,
         scheduleId: schedule.id,
       });