@covibes/zeroshot 5.3.0 → 5.4.0

package/task-lib/commands/logs.js

@@ -30,58 +30,70 @@ function getToolIcon(toolName) {
 }
 
 // Format tool call input for display
+const TOOL_CALL_FORMATTERS = {
+  Bash: (input) => (input.command ? `$ ${input.command}` : ''),
+  Read: (input) => formatFilePathTail(input.file_path),
+  Write: (input) => formatFilePathTail(input.file_path, '→ '),
+  Edit: (input) => formatFilePathTail(input.file_path),
+  Glob: (input) => input.pattern || '',
+  Grep: (input) => (input.pattern ? `/${input.pattern}/` : ''),
+  WebFetch: (input) => (input.url ? input.url.substring(0, 50) : ''),
+  WebSearch: (input) => (input.query ? `"${input.query}"` : ''),
+  Task: (input) => input.description || '',
+  TodoWrite: (input) => formatTodoSummary(input),
+  AskUserQuestion: (input) => formatQuestionSummary(input),
+};
+
 function formatToolCall(toolName, input) {
   if (!input) return '';
 
-  switch (toolName) {
-    case 'Bash':
-      return input.command ? `$ ${input.command}` : '';
-    case 'Read':
-      return input.file_path ? input.file_path.split('/').slice(-2).join('/') : '';
-    case 'Write':
-      return input.file_path ? `→ ${input.file_path.split('/').slice(-2).join('/')}` : '';
-    case 'Edit':
-      return input.file_path ? input.file_path.split('/').slice(-2).join('/') : '';
-    case 'Glob':
-      return input.pattern || '';
-    case 'Grep':
-      return input.pattern ? `/${input.pattern}/` : '';
-    case 'WebFetch':
-      return input.url ? input.url.substring(0, 50) : '';
-    case 'WebSearch':
-      return input.query ? `"${input.query}"` : '';
-    case 'Task':
-      return input.description || '';
-    case 'TodoWrite':
-      if (input.todos && Array.isArray(input.todos)) {
-        const statusCounts = {};
-        input.todos.forEach((todo) => {
-          statusCounts[todo.status] = (statusCounts[todo.status] || 0) + 1;
-        });
-        const parts = Object.entries(statusCounts).map(
-          ([status, count]) => `${count} ${status.replace('_', ' ')}`
-        );
-        return `${input.todos.length} todo${input.todos.length === 1 ? '' : 's'} (${parts.join(', ')})`;
-      }
-      return '';
-    case 'AskUserQuestion':
-      if (input.questions && Array.isArray(input.questions)) {
-        const q = input.questions[0];
-        const preview = q.question.substring(0, 50);
-        return input.questions.length > 1
-          ? `${input.questions.length} questions: "${preview}..."`
-          : `"${preview}${q.question.length > 50 ? '...' : ''}"`;
-      }
-      return '';
-    default:
-      // For unknown tools, show first key-value pair
-      const keys = Object.keys(input);
-      if (keys.length > 0) {
-        const val = String(input[keys[0]]).substring(0, 40);
-        return val.length < String(input[keys[0]]).length ? val + '...' : val;
-      }
-      return '';
+  const formatter = TOOL_CALL_FORMATTERS[toolName] || formatUnknownToolCall;
+  return formatter(input);
+}
+
+function formatFilePathTail(filePath, prefix = '') {
+  if (!filePath) return '';
+  return `${prefix}${filePath.split('/').slice(-2).join('/')}`;
+}
+
+function formatTodoSummary(input) {
+  const todos = input.todos;
+  if (!Array.isArray(todos)) return '';
+
+  const statusCounts = {};
+  for (const todo of todos) {
+    statusCounts[todo.status] = (statusCounts[todo.status] || 0) + 1;
+  }
+
+  const parts = Object.entries(statusCounts).map(
+    ([status, count]) => `${count} ${status.replace('_', ' ')}`
+  );
+
+  return `${todos.length} todo${todos.length === 1 ? '' : 's'} (${parts.join(', ')})`;
+}
+
+function formatQuestionSummary(input) {
+  const questions = input.questions;
+  if (!Array.isArray(questions) || questions.length === 0) {
+    return '';
+  }
+
+  const preview = questions[0].question.substring(0, 50);
+  const suffix = questions[0].question.length > 50 ? '...' : '';
+  return questions.length > 1
+    ? `${questions.length} questions: "${preview}..."`
+    : `"${preview}${suffix}"`;
+}
+
+function formatUnknownToolCall(input) {
+  const keys = Object.keys(input);
+  if (keys.length === 0) {
+    return '';
   }
+
+  const value = String(input[keys[0]]);
+  const preview = value.substring(0, 40);
+  return preview.length < value.length ? `${preview}...` : preview;
 }
 
 // Format tool result for display
@@ -98,16 +110,21 @@ function formatToolResult(content, isError, toolName, toolInput) {
   if (toolName === 'TodoWrite' && toolInput?.todos && Array.isArray(toolInput.todos)) {
     const todos = toolInput.todos;
     if (todos.length === 0) return chalk.dim('no todos');
+
+    // Helper to get status icon
+    const getStatusIcon = (todoStatus) => {
+      if (todoStatus === 'completed') return '✓';
+      if (todoStatus === 'in_progress') return '⧗';
+      return '○';
+    };
+
     if (todos.length === 1) {
-      const status =
-        todos[0].status === 'completed' ? '✓' : todos[0].status === 'in_progress' ? '⧗' : '○';
-      return chalk.dim(
-        `${status} ${todos[0].content.substring(0, 50)}${todos[0].content.length > 50 ? '...' : ''}`
-      );
+      const status = getStatusIcon(todos[0].status);
+      const suffix = todos[0].content.length > 50 ? '...' : '';
+      return chalk.dim(`${status} ${todos[0].content.substring(0, 50)}${suffix}`);
     }
     // Multiple todos - show first one as preview
-    const status =
-      todos[0].status === 'completed' ? '✓' : todos[0].status === 'in_progress' ? '⧗' : '○';
+    const status = getStatusIcon(todos[0].status);
     return chalk.dim(
       `${status} ${todos[0].content.substring(0, 40)}... (+${todos.length - 1} more)`
     );
@@ -161,77 +178,95 @@ function accumulateText(text) {
 }
 
 // Process parsed events and output formatted content
+const EVENT_HANDLERS = {
+  text: handleTextEvent,
+  thinking: handleThinkingEvent,
+  thinking_start: handleThinkingEvent,
+  tool_start: handleToolStart,
+  tool_call: handleToolCall,
+  tool_input: handleToolInput,
+  tool_result: handleToolResult,
+  result: handleResult,
+  block_end: handleBlockEnd,
+  multi: handleMulti,
+};
+
 function processEvent(event) {
-  switch (event.type) {
-    case 'text':
-      accumulateText(event.text);
-      break;
-
-    case 'thinking':
-    case 'thinking_start':
-      if (event.text) {
-        console.log(chalk.dim.italic(event.text));
-      } else if (event.type === 'thinking_start') {
-        console.log(chalk.dim.italic('💭 thinking...'));
-      }
-      break;
-
-    case 'tool_start':
-      flushLineBuffer();
-      break;
-
-    case 'tool_call':
-      flushLineBuffer();
-      const icon = getToolIcon(event.toolName);
-      const toolDesc = formatToolCall(event.toolName, event.input);
-      console.log(`${icon} ${chalk.cyan(event.toolName)} ${chalk.dim(toolDesc)}`);
-      currentToolCall = { toolName: event.toolName, input: event.input };
-      break;
-
-    case 'tool_input':
-      // Streaming tool input JSON - skip (shown in tool_call)
-      break;
-
-    case 'tool_result':
-      const status = event.isError ? chalk.red('✗') : chalk.green('✓');
-      const resultDesc = formatToolResult(
-        event.content,
-        event.isError,
-        currentToolCall?.toolName,
-        currentToolCall?.input
-      );
-      console.log(`  ${status} ${resultDesc}`);
-      break;
-
-    case 'result':
-      flushLineBuffer();
-      if (event.error) {
-        console.log(chalk.red(`\n✗ ERROR: ${event.error}`));
-      } else {
-        console.log(chalk.green(`\n✓ Completed`));
-        if (event.cost) {
-          console.log(chalk.dim(`   Cost: $${event.cost.toFixed(4)}`));
-        }
-        if (event.duration) {
-          const mins = Math.floor(event.duration / 60000);
-          const secs = Math.floor((event.duration % 60000) / 1000);
-          console.log(chalk.dim(`   Duration: ${mins}m ${secs}s`));
-        }
-      }
-      break;
-
-    case 'block_end':
-      // Content block ended
-      break;
-
-    case 'multi':
-      // Multiple events
-      if (event.events) {
-        for (const e of event.events) {
-          processEvent(e);
-        }
-      }
-      break;
+  const handler = EVENT_HANDLERS[event.type];
+  if (handler) {
+    handler(event);
+  }
+}
+
+function handleTextEvent(event) {
+  accumulateText(event.text);
+}
+
+function handleThinkingEvent(event) {
+  if (event.text) {
+    console.log(chalk.dim.italic(event.text));
+    return;
+  }
+
+  if (event.type === 'thinking_start') {
+    console.log(chalk.dim.italic('💭 thinking...'));
+  }
+}
+
+function handleToolStart() {
+  flushLineBuffer();
+}
+
+function handleToolCall(event) {
+  flushLineBuffer();
+  const icon = getToolIcon(event.toolName);
+  const toolDesc = formatToolCall(event.toolName, event.input);
+  console.log(`${icon} ${chalk.cyan(event.toolName)} ${chalk.dim(toolDesc)}`);
+  currentToolCall = { toolName: event.toolName, input: event.input };
+}
+
+function handleToolInput() {
+  // Streaming tool input JSON - skip (shown in tool_call)
+}
+
+function handleToolResult(event) {
+  const status = event.isError ? chalk.red('✗') : chalk.green('✓');
+  const resultDesc = formatToolResult(
+    event.content,
+    event.isError,
+    currentToolCall?.toolName,
+    currentToolCall?.input
+  );
+  console.log(`  ${status} ${resultDesc}`);
+}
+
+function handleResult(event) {
+  flushLineBuffer();
+  if (event.error) {
+    console.log(chalk.red(`\n✗ ERROR: ${event.error}`));
+    return;
+  }
+
+  console.log(chalk.green(`\n✓ Completed`));
+  if (event.cost) {
+    console.log(chalk.dim(`   Cost: $${event.cost.toFixed(4)}`));
+  }
+  if (event.duration) {
+    const mins = Math.floor(event.duration / 60000);
+    const secs = Math.floor((event.duration % 60000) / 1000);
+    console.log(chalk.dim(`   Duration: ${mins}m ${secs}s`));
+  }
+}
+
+function handleBlockEnd() {
+  // Content block ended
+}
+
+function handleMulti(event) {
+  if (event.events) {
+    for (const subEvent of event.events) {
+      processEvent(subEvent);
+    }
   }
 }
 
@@ -296,23 +331,73 @@ export async function showLogs(taskId, options = {}) {
   }
 }
 
+function parseEventsFromLines(lines) {
+  const events = [];
+  for (const line of lines) {
+    events.push(...parseLogLine(line));
+  }
+  return events;
+}
+
+function renderEvents(events) {
+  for (const event of events) {
+    processEvent(event);
+  }
+}
+
+function renderLines(lines) {
+  for (const line of lines) {
+    renderEvents(parseLogLine(line));
+  }
+}
+
+function readFileSlice(file, start, end) {
+  const length = Math.max(0, end - start);
+  if (!length) return '';
+
+  const buffer = Buffer.alloc(length);
+  const fd = openSync(file, 'r');
+  readSync(fd, buffer, 0, buffer.length, start);
+  closeSync(fd);
+
+  return buffer.toString();
+}
+
+function shouldStopFollowing(noChangeCount, pid) {
+  return noChangeCount >= 10 && pid && !isProcessRunning(pid);
+}
+
+function handleFinalContent(file, lastSize, interval) {
+  const finalSize = statSync(file).size;
+  if (finalSize > lastSize) {
+    const finalContent = readFileSlice(file, lastSize, finalSize);
+    renderLines(finalContent.split('\n'));
+    flushLineBuffer();
+  }
+
+  console.log(chalk.dim('\n--- Task completed ---'));
+  clearInterval(interval);
+  process.exit(0);
+}
+
+function handleNewContent(file, lastSize, currentSize) {
+  const newContent = readFileSlice(file, lastSize, currentSize);
+  if (newContent) {
+    renderLines(newContent.split('\n'));
+    flushLineBuffer();
+  }
+  return currentSize;
+}
+
 function tailLines(file, n) {
   resetState();
   const rawContent = readFileSync(file, 'utf-8');
   const rawLines = rawContent.split('\n');
 
   // Parse and process all events
-  const allEvents = [];
-  for (const line of rawLines) {
-    const events = parseLogLine(line);
-    allEvents.push(...events);
-  }
-
+  const allEvents = parseEventsFromLines(rawLines);
   // Tail to last n events
-  const tailedEvents = allEvents.slice(-n);
-  for (const event of tailedEvents) {
-    processEvent(event);
-  }
+  renderEvents(allEvents.slice(-n));
   flushLineBuffer();
 }
 
@@ -323,17 +408,9 @@ async function tailFollow(file, pid, lines = 50) {
   const rawLines = rawContent.split('\n');
 
   // Parse all events first
-  const allEvents = [];
-  for (const line of rawLines) {
-    const events = parseLogLine(line);
-    allEvents.push(...events);
-  }
-
+  const allEvents = parseEventsFromLines(rawLines);
   // Output only the last N events
-  const tailedEvents = allEvents.slice(-lines);
-  for (const event of tailedEvents) {
-    processEvent(event);
-  }
+  renderEvents(allEvents.slice(-lines));
   flushLineBuffer();
 
   // Poll for changes (more reliable than fs.watch)
@@ -345,51 +422,16 @@ async function tailFollow(file, pid, lines = 50) {
       const currentSize = statSync(file).size;
 
       if (currentSize > lastSize) {
-        // Read new content
-        const buffer = Buffer.alloc(currentSize - lastSize);
-        const fd = openSync(file, 'r');
-        readSync(fd, buffer, 0, buffer.length, lastSize);
-        closeSync(fd);
-
-        // Parse and output new lines
-        const newLines = buffer.toString().split('\n');
-        for (const line of newLines) {
-          const events = parseLogLine(line);
-          for (const event of events) {
-            processEvent(event);
-          }
-        }
-        flushLineBuffer();
-
-        lastSize = currentSize;
+        lastSize = handleNewContent(file, lastSize, currentSize);
         noChangeCount = 0;
-      } else {
-        noChangeCount++;
-
-        // Check if process is still running after 5 seconds of no output
-        if (noChangeCount >= 10 && pid && !isProcessRunning(pid)) {
-          // Read any final content
-          const finalSize = statSync(file).size;
-          if (finalSize > lastSize) {
-            const buffer = Buffer.alloc(finalSize - lastSize);
-            const fd = openSync(file, 'r');
-            readSync(fd, buffer, 0, buffer.length, lastSize);
-            closeSync(fd);
-
-            const finalLines = buffer.toString().split('\n');
-            for (const line of finalLines) {
-              const events = parseLogLine(line);
-              for (const event of events) {
-                processEvent(event);
-              }
-            }
-            flushLineBuffer();
-          }
-
-          console.log(chalk.dim('\n--- Task completed ---'));
-          clearInterval(interval);
-          process.exit(0);
-        }
+        return;
+      }
+
+      noChangeCount++;
+
+      // Check if process is still running after 5 seconds of no output
+      if (shouldStopFollowing(noChangeCount, pid)) {
+        handleFinalContent(file, lastSize, interval);
       }
     } catch (err) {
       // File might have been deleted

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`;
 }