@covibes/zeroshot 5.3.0 → 5.4.0

package/src/tui/renderer.js

@@ -37,11 +37,9 @@ class Renderer {
    * @param {Array} clusters - Array of cluster objects
    */
   renderClustersTable(clusters) {
-    if (!clusters || !Array.isArray(clusters)) {
-      clusters = [];
-    }
+    const clusterList = !clusters || !Array.isArray(clusters) ? [] : clusters;
 
-    const data = clusters.map((c) => {
+    const data = clusterList.map((c) => {
       if (!c) return ['', '', '', ''];
 
       const icon = stateIcon(c.state || 'unknown');
@@ -68,23 +66,19 @@ class Renderer {
    * @param {Map} resourceStats - Map of PID -> {cpu, memory}
    */
   renderSystemStats(clusters, resourceStats) {
-    if (!clusters || !Array.isArray(clusters)) {
-      clusters = [];
-    }
-    if (!resourceStats || !(resourceStats instanceof Map)) {
-      resourceStats = new Map();
-    }
+    const clusterList = !clusters || !Array.isArray(clusters) ? [] : clusters;
+    const statsMap = !resourceStats || !(resourceStats instanceof Map) ? new Map() : resourceStats;
 
     // Calculate aggregate stats
-    const activeClusters = clusters.filter((c) => c && c.state === 'running').length;
-    const totalAgents = clusters.reduce((sum, c) => sum + (c?.agentCount || 0), 0);
+    const activeClusters = clusterList.filter((c) => c && c.state === 'running').length;
+    const totalAgents = clusterList.reduce((sum, c) => sum + (c?.agentCount || 0), 0);
 
     // Calculate average CPU and memory from resource stats
     let totalCpu = 0;
     let totalMemory = 0;
     let statCount = 0;
 
-    resourceStats.forEach((stat) => {
+    statsMap.forEach((stat) => {
       if (stat && typeof stat.cpu === 'number' && typeof stat.memory === 'number') {
         totalCpu += stat.cpu;
         totalMemory += stat.memory;
@@ -125,18 +119,14 @@ class Renderer {
       return;
     }
 
-    if (!agents || !Array.isArray(agents)) {
-      agents = [];
-    }
-    if (!resourceStats || !(resourceStats instanceof Map)) {
-      resourceStats = new Map();
-    }
+    const agentList = !agents || !Array.isArray(agents) ? [] : agents;
+    const statsMap = !resourceStats || !(resourceStats instanceof Map) ? new Map() : resourceStats;
 
-    const data = agents.map((a) => {
+    const data = agentList.map((a) => {
       if (!a) return ['', '', '', '', '', ''];
 
       const pid = a.pid;
-      const stats = resourceStats.get(pid) || { cpu: 0, memory: 0 };
+      const stats = statsMap.get(pid) || { cpu: 0, memory: 0 };
 
       const agentId = truncate(a.id || '', 12);
       const role = truncate(a.role || '', 12);

package/task-lib/attachable-watcher.js

@@ -96,6 +96,115 @@ let finalResultJson = null;
 let outputBuffer = '';
 let streamingModeError = null;
 
+function splitBufferLines(buffer, chunk) {
+  const nextBuffer = buffer + chunk;
+  const lines = nextBuffer.split('\n');
+  const remaining = lines.pop() || '';
+  return { lines, remaining };
+}
+
+function captureStreamingError(line, timestamp) {
+  if (!enableRecovery) {
+    return false;
+  }
+
+  const detectedError = detectStreamingModeError(line);
+  if (!detectedError) {
+    return false;
+  }
+
+  streamingModeError = { ...detectedError, timestamp };
+  return true;
+}
+
+function maybeCaptureStructuredOutput(line) {
+  try {
+    const json = JSON.parse(line);
+    if (json.structured_output) {
+      finalResultJson = line;
+    }
+  } catch {
+    // Not JSON, skip
+  }
+}
+
+function handleSilentJsonLines(lines, timestamp) {
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    if (captureStreamingError(line, timestamp)) {
+      continue;
+    }
+    maybeCaptureStructuredOutput(line);
+  }
+}
+
+function handleStreamingLines(lines, timestamp) {
+  for (const line of lines) {
+    if (captureStreamingError(line, timestamp)) {
+      continue;
+    }
+    log(`[${timestamp}]${line}\n`);
+  }
+}
+
+function flushOutputBuffer(timestamp) {
+  if (!outputBuffer.trim()) {
+    return;
+  }
+
+  if (!enableRecovery) {
+    if (!silentJsonMode) {
+      log(`[${timestamp}]${outputBuffer}\n`);
+    }
+    return;
+  }
+
+  if (captureStreamingError(outputBuffer, timestamp)) {
+    return;
+  }
+
+  if (silentJsonMode) {
+    maybeCaptureStructuredOutput(outputBuffer);
+    return;
+  }
+
+  log(`[${timestamp}]${outputBuffer}\n`);
+}
+
+function attemptRecovery(code, timestamp) {
+  if (!(enableRecovery && code !== 0 && streamingModeError?.sessionId)) {
+    return null;
+  }
+
+  const recovered = recoverStructuredOutput(streamingModeError.sessionId);
+  if (recovered?.payload) {
+    const recoveredLine = JSON.stringify(recovered.payload);
+    if (silentJsonMode) {
+      finalResultJson = recoveredLine;
+    } else {
+      log(`[${timestamp}]${recoveredLine}\n`);
+    }
+  } else if (streamingModeError.line) {
+    if (silentJsonMode) {
+      log(streamingModeError.line + '\n');
+    } else {
+      log(`[${streamingModeError.timestamp}]${streamingModeError.line}\n`);
+    }
+  }
+
+  return recovered;
+}
+
+function writeCompletionFooter(code, signal) {
+  if (config.outputFormat === 'json') {
+    return;
+  }
+
+  log(`\n${'='.repeat(50)}\n`);
+  log(`Finished: ${new Date().toISOString()}\n`);
+  log(`Exit code: ${code}, Signal: ${signal}\n`);
+}
+
 const server = new AttachServer({
   id: taskId,
   socketPath,
@@ -111,44 +220,13 @@ server.on('output', (data) => {
   const chunk = data.toString();
   const timestamp = Date.now();
 
+  const { lines, remaining } = splitBufferLines(outputBuffer, chunk);
+  outputBuffer = remaining;
+
   if (silentJsonMode) {
-    outputBuffer += chunk;
-    const lines = outputBuffer.split('\n');
-    outputBuffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      if (enableRecovery) {
-        const detectedError = detectStreamingModeError(line);
-        if (detectedError) {
-          streamingModeError = { ...detectedError, timestamp };
-          continue;
-        }
-      }
-      try {
-        const json = JSON.parse(line);
-        if (json.structured_output) {
-          finalResultJson = line;
-        }
-      } catch {
-        // Not JSON, skip
-      }
-    }
+    handleSilentJsonLines(lines, timestamp);
   } else {
-    outputBuffer += chunk;
-    const lines = outputBuffer.split('\n');
-    outputBuffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (enableRecovery) {
-        const detectedError = detectStreamingModeError(line);
-        if (detectedError) {
-          streamingModeError = { ...detectedError, timestamp };
-          continue;
-        }
-      }
-      log(`[${timestamp}]${line}\n`);
-    }
+    handleStreamingLines(lines, timestamp);
   }
 });
 
@@ -156,56 +234,15 @@ server.on('exit', async ({ exitCode, signal }) => {
   const timestamp = Date.now();
   const code = exitCode;
 
-  if (outputBuffer.trim()) {
-    if (enableRecovery) {
-      const detectedError = detectStreamingModeError(outputBuffer);
-      if (detectedError) {
-        streamingModeError = { ...detectedError, timestamp };
-      } else if (silentJsonMode) {
-        try {
-          const json = JSON.parse(outputBuffer);
-          if (json.structured_output) {
-            finalResultJson = outputBuffer;
-          }
-        } catch {
-          // Not valid JSON
-        }
-      } else {
-        log(`[${timestamp}]${outputBuffer}\n`);
-      }
-    } else if (!silentJsonMode) {
-      log(`[${timestamp}]${outputBuffer}\n`);
-    }
-  }
+  flushOutputBuffer(timestamp);
 
-  let recovered = null;
-  if (enableRecovery && code !== 0 && streamingModeError?.sessionId) {
-    recovered = recoverStructuredOutput(streamingModeError.sessionId);
-    if (recovered?.payload) {
-      const recoveredLine = JSON.stringify(recovered.payload);
-      if (silentJsonMode) {
-        finalResultJson = recoveredLine;
-      } else {
-        log(`[${timestamp}]${recoveredLine}\n`);
-      }
-    } else if (streamingModeError.line) {
-      if (silentJsonMode) {
-        log(streamingModeError.line + '\n');
-      } else {
-        log(`[${streamingModeError.timestamp}]${streamingModeError.line}\n`);
-      }
-    }
-  }
+  const recovered = attemptRecovery(code, timestamp);
 
   if (silentJsonMode && finalResultJson) {
     log(finalResultJson + '\n');
   }
 
-  if (config.outputFormat !== 'json') {
-    log(`\n${'='.repeat(50)}\n`);
-    log(`Finished: ${new Date().toISOString()}\n`);
-    log(`Exit code: ${code}, Signal: ${signal}\n`);
-  }
+  writeCompletionFooter(code, signal);
 
   const resolvedCode = recovered?.payload ? 0 : code;
   const status = resolvedCode === 0 ? 'completed' : 'failed';
@@ -213,7 +250,7 @@ server.on('exit', async ({ exitCode, signal }) => {
     await updateTask(taskId, {
       status,
       exitCode: resolvedCode,
-      error: resolvedCode === 0 ? null : signal ? `Killed by ${signal}` : null,
+      error: resolvedCode !== 0 && signal ? `Killed by ${signal}` : null,
       socketPath: null,
     });
   } catch (updateError) {

package/task-lib/claude-recovery.js

@@ -66,40 +66,80 @@ export function recoverStructuredOutput(sessionId) {
   const jsonlPath = findSessionJsonlPath(sessionId);
   if (!jsonlPath) return null;
 
-  let fileContents;
+  const fileContents = readJsonlFile(jsonlPath);
+  if (!fileContents) return null;
+
+  const { structuredOutput, usage } = findStructuredOutput(fileContents);
+
+  if (!structuredOutput) return null;
+
+  return {
+    payload: buildStructuredOutputPayload(sessionId, structuredOutput, usage),
+    sourcePath: jsonlPath,
+  };
+}
+
+function readJsonlFile(jsonlPath) {
   try {
-    fileContents = readFileSync(jsonlPath, 'utf8');
+    return readFileSync(jsonlPath, 'utf8');
   } catch {
     return null;
   }
+}
 
+function findStructuredOutput(fileContents) {
   const lines = fileContents.split('\n');
   let structuredOutput = null;
   let usage = null;
 
   for (const line of lines) {
-    if (!line.trim()) continue;
-    try {
-      const entry = JSON.parse(line);
-      const message = entry?.message;
-      const content = message?.content;
-      if (!Array.isArray(content)) continue;
-
-      for (const block of content) {
-        if (block?.type === 'tool_use' && block?.name === 'StructuredOutput' && block?.input) {
-          structuredOutput = block.input;
-          if (message?.usage && typeof message.usage === 'object') {
-            usage = message.usage;
-          }
-        }
-      }
-    } catch {
-      // Skip invalid JSON lines
+    const entry = parseJsonLine(line);
+    if (!entry) {
+      continue;
+    }
+
+    const extracted = extractStructuredOutputFromEntry(entry);
+    if (extracted) {
+      structuredOutput = extracted.structuredOutput;
+      usage = extracted.usage;
     }
   }
 
-  if (!structuredOutput) return null;
+  return { structuredOutput, usage };
+}
+
+function parseJsonLine(line) {
+  if (!line.trim()) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    // Skip invalid JSON lines
+    return null;
+  }
+}
 
+function extractStructuredOutputFromEntry(entry) {
+  const message = entry?.message;
+  const content = message?.content;
+  if (!Array.isArray(content)) return null;
+
+  let structuredOutput = null;
+  let usage = null;
+  for (const block of content) {
+    if (block?.type === 'tool_use' && block?.name === 'StructuredOutput' && block?.input) {
+      structuredOutput = block.input;
+      usage = message?.usage && typeof message.usage === 'object' ? message.usage : null;
+    }
+  }
+
+  if (!structuredOutput) {
+    return null;
+  }
+
+  return { structuredOutput, usage };
+}
+
+function buildStructuredOutputPayload(sessionId, structuredOutput, usage) {
   const payload = {
     type: 'result',
     subtype: 'success',
@@ -112,8 +152,5 @@ export function recoverStructuredOutput(sessionId) {
     payload.usage = usage;
   }
 
-  return {
-    payload,
-    sourcePath: jsonlPath,
-  };
+  return payload;
 }

package/task-lib/commands/episodes.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { loadTasks } from '../store.js';
+import { isProcessRunning } from '../runner.js';
+
+export function listEpisodes(options = {}) {
+  const tasks = loadTasks();
+  const taskList = Object.values(tasks);
+
+  if (taskList.length === 0) {
+    console.log(chalk.dim('No episodes found.'));
+    return;
+  }
+
+  // Sort by creation date, oldest first (chronological order)
+  taskList.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+
+  // Filter by status if specified
+  let filtered = taskList;
+  if (options.status) {
+    filtered = taskList.filter((t) => t.status === options.status);
+  }
+
+  // Limit results
+  const limit = options.limit || 20;
+  filtered = filtered.slice(0, limit);
+
+  // Table format (default) or verbose format
+  if (options.verbose) {
+    // Verbose format (old behavior)
+    console.log(chalk.bold(`\nEpisodes (${filtered.length}/${taskList.length})\n`));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.green,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const timestamp = new Date(task.createdAt).toLocaleString();
+
+      console.log(
+        `${statusColor('●')} ${chalk.cyan(task.id)} ${statusColor(`[${status}]`)} ${chalk.dim(age + ' • ' + timestamp)}`
+      );
+      console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
+      console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
+      if (task.pid && status === 'running') {
+        console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
+      }
+      if (task.error) {
+        console.log(`  ${chalk.red('Error:')} ${task.error}`);
+      }
+      console.log();
+    }
+  } else {
+    // Table format (clean, default)
+    console.log(chalk.bold(`\n=== Episodes (${filtered.length}/${taskList.length}) ===`));
+    console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
+    console.log('-'.repeat(100));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.green,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const cwd = task.cwd.replace(process.env.HOME, '~');
+
+      console.log(
+        `${chalk.cyan(task.id.padEnd(25))} ${statusColor(status.padEnd(12))} ${chalk.dim(age.padEnd(10))} ${chalk.dim(cwd)}`
+      );
+    }
+    console.log();
+  }
+}
+
+function getAge(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(mins / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (mins > 0) return `${mins}m ago`;
+  return 'just now';
+}

package/task-lib/commands/list.js

@@ -11,8 +11,8 @@ export function listTasks(options = {}) {
     return;
   }
 
-  // Sort by creation date, newest first
-  taskList.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+  // Sort by creation date, oldest first (chronological)
+  taskList.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
 
   // Filter by status if specified
   let filtered = taskList;