bunosh 0.4.1 → 0.4.7

package/src/task.js

@@ -28,15 +28,23 @@ export function ignoreFail(enable = true) {
 }
 
 // Global failure mode control
-// true = stop on failures (exit with code 1), false = continue on failures
 let stopOnFailuresMode = false;
+let ignoreFailuresMode = false;
 
 export function ignoreFailures() {
   stopOnFailuresMode = false;
+  ignoreFailuresMode = true;
+  globalThis._bunoshIgnoreFailuresMode = true;
 }
 
 export function stopOnFailures() {
   stopOnFailuresMode = true;
+  ignoreFailuresMode = false;
+  globalThis._bunoshIgnoreFailuresMode = false;
+}
+
+export function getIgnoreFailuresMode() {
+  return ignoreFailuresMode;
 }
 
 export function silence() {
@@ -185,7 +193,7 @@ export async function task(name, fn, isSilent = false) {
     printer.finish(name);
     runningTasks.delete(taskInfo.id);
 
-    return result;
+    return TaskResult.success(result, { taskType: 'task' });
   } catch (err) {
     const endTime = Date.now();
     const duration = endTime - taskInfo.startTime;
@@ -198,9 +206,16 @@ export async function task(name, fn, isSilent = false) {
     runningTasks.delete(taskInfo.id);
 
     // Don't exit during testing
+    const commandArgs = process.argv.slice(2);
     const isTestEnvironment = process.env.NODE_ENV === 'test' ||
                               typeof Bun?.jest !== 'undefined' ||
-                              process.argv.some(arg => arg.includes('vitest') || arg.includes('jest') || arg.includes('--test') || arg.includes('test:'));
+                              commandArgs.some(arg => {
+                                const lowerArg = arg.toLowerCase();
+                                return lowerArg.includes('vitest') ||
+                                       lowerArg.includes('jest') ||
+                                       lowerArg === '--test' ||
+                                       lowerArg.startsWith('test:');
+                              });
 
     // Exit immediately if stopOnFailures mode is enabled
     if (stopOnFailuresMode && !isTestEnvironment) {
@@ -212,13 +227,14 @@ export async function task(name, fn, isSilent = false) {
       process.exit(1);
     }
     
-    throw err;
+    return TaskResult.fail(err.message, { taskType: 'task', error: err });
   }
 }
 
 // Add try method to task function
 task.try = tryTask;
 
+
 export class SilentTaskWrapper {
   constructor() {
     this.silent = true;
@@ -246,9 +262,10 @@ export function silent() {
 }
 
 export class TaskResult {
-  constructor({ status, output }) {
+  constructor({ status, output, metadata = {} }) {
     this.status = status;
     this.output = output;
+    this._metadata = metadata;
   }
 
   get hasFailed() {
@@ -263,15 +280,76 @@ export class TaskResult {
     return this.status === TaskStatus.WARNING;
   }
 
-  static fail(output = null) {
-    return new TaskResult({ status: TaskStatus.FAIL, output });
+  async json() {
+    const taskType = this._metadata.taskType || 'unknown';
+    
+    switch (taskType) {
+      case 'fetch':
+        // For fetch tasks, parse the response body as JSON
+        if (this._metadata.response) {
+          try {
+            return await this._metadata.response.json();
+          } catch (error) {
+            throw new Error(`Failed to parse fetch response as JSON: ${error.message}`);
+          }
+        } else if (typeof this.output === 'string') {
+          try {
+            return JSON.parse(this.output);
+          } catch (error) {
+            throw new Error(`Failed to parse fetch output as JSON: ${error.message}`);
+          }
+        }
+        throw new Error('No JSON data available from fetch task');
+
+      case 'exec':
+      case 'shell':
+        // For exec/shell tasks, return structured output
+        const lines = this.output ? this.output.split('\n').filter(line => line.trim()) : [];
+        return {
+          stdout: this._metadata.stdout || this.output || '',
+          stderr: this._metadata.stderr || '',
+          exitCode: this._metadata.exitCode || (this.hasFailed ? 1 : 0),
+          lines
+        };
+
+      case 'ai':
+        // For AI tasks, return the structured output if available
+        if (typeof this.output === 'object') {
+          return this.output;
+        } else if (typeof this.output === 'string') {
+          try {
+            return JSON.parse(this.output);
+          } catch (error) {
+            // If it's not JSON, return as text property
+            return { text: this.output };
+          }
+        }
+        return { text: this.output || '' };
+
+      default:
+        // For unknown task types, try to parse output as JSON or return as text
+        if (typeof this.output === 'object') {
+          return this.output;
+        } else if (typeof this.output === 'string') {
+          try {
+            return JSON.parse(this.output);
+          } catch (error) {
+            return { text: this.output };
+          }
+        }
+        return { text: this.output || '' };
+    }
+  }
+
+  static fail(output = null, metadata = {}) {
+    return new TaskResult({ status: TaskStatus.FAIL, output, metadata });
   }
 
-  static success(output = null) {
-    return new TaskResult({ status: TaskStatus.SUCCESS, output });
+  static success(output = null, metadata = {}) {
+    return new TaskResult({ status: TaskStatus.SUCCESS, output, metadata });
   }
 
-  static warning(output = null) {
-    return new TaskResult({ status: TaskStatus.WARNING, output });
+  static warning(output = null, metadata = {}) {
+    return new TaskResult({ status: TaskStatus.WARNING, output, metadata });
   }
 }

package/src/tasks/ai.js

@@ -118,15 +118,23 @@ async function ai(prompt, outputFormat = null) {
     process.stdout.write('\r' + ' '.repeat(20) + '\r');
     const tokenInfo = usage ? `${usage.totalTokens} tokens` : '';
     printer.finish(taskName, { tokenInfo });
+    
+    const metadata = {
+      taskType: 'ai',
+      outputFormat: !!outputFormat,
+      usage,
+      prompt: cleanPrompt
+    };
+    
     finishTaskInfo(taskInfo, true, null, outputFormat ? JSON.stringify(result, null, 2) : result);
-    return TaskResult.success(result);
+    return TaskResult.success(result, metadata);
     
   } catch (error) {
     clearInterval(progressInterval);
     process.stdout.write('\r' + ' '.repeat(20) + '\r');
     printer.error(taskName, error);
     finishTaskInfo(taskInfo, false, error, error.message);
-    return TaskResult.fail(error.message);
+    return TaskResult.fail(error.message, { taskType: 'ai' });
   }
 }
 

package/src/tasks/exec.js

@@ -62,6 +62,8 @@ export default function exec(strings, ...values) {
 
       const decoder = new TextDecoder();
       let output = '';
+      let stdout = '';
+      let stderr = '';
       let finished = false;
 
       // Process stdout
@@ -84,6 +86,7 @@ export default function exec(strings, ...values) {
               if (line.trim()) {
                 printer.output(line);
                 output += line + '\n';
+                stdout += line + '\n';
               }
             }
           }
@@ -91,6 +94,7 @@ export default function exec(strings, ...values) {
           if (buffer.trim()) {
             printer.output(buffer);
             output += buffer + '\n';
+            stdout += buffer + '\n';
           }
         } finally {
           reader.releaseLock();
@@ -117,6 +121,7 @@ export default function exec(strings, ...values) {
               if (line.trim()) {
                 printer.output(line, true);
                 output += line + '\n';
+                stderr += line + '\n';
               }
             }
           }
@@ -124,6 +129,7 @@ export default function exec(strings, ...values) {
           if (buffer.trim()) {
             printer.output(buffer, true);
             output += buffer + '\n';
+            stderr += buffer + '\n';
           }
         } finally {
           reader.releaseLock();
@@ -140,20 +146,27 @@ export default function exec(strings, ...values) {
       finished = true;
       const exitCode = parseInt(exitResult, 10);
 
+      const metadata = {
+        taskType: 'exec',
+        exitCode,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      };
+
       if (exitCode === 0) {
         printer.finish(cmd);
         finishTaskInfo(taskInfo, true, null, output.trim());
-        resolve(TaskResult.success(output.trim()));
+        resolve(TaskResult.success(output.trim(), metadata));
       } else {
         const error = new Error(`Exit code: ${exitCode}`);
         printer.error(cmd, null, { exitCode });
         finishTaskInfo(taskInfo, false, error, output.trim());
-        resolve(TaskResult.fail(output.trim()));
+        resolve(TaskResult.fail(output.trim(), metadata));
       }
     } catch (error) {
       printer.error(cmd, error);
       finishTaskInfo(taskInfo, false, error, error.message);
-      resolve(TaskResult.fail(error.message));
+      resolve(TaskResult.fail(error.message, { taskType: 'exec' }));
     }
   });
 
@@ -182,35 +195,44 @@ async function nodeExec(cmd, extraInfo, printer, taskInfo) {
     });
     
     let output = '';
-    let errorOutput = '';
+    let stdout = '';
+    let stderr = '';
     
     proc.stdout.on('data', (data) => {
       const text = data.toString();
       printer.output(text.trim());
       output += text;
+      stdout += text;
     });
     
     proc.stderr.on('data', (data) => {
       const text = data.toString();
       printer.output(text.trim(), true);
-      errorOutput += text;
+      output += text;
+      stderr += text;
     });
     
     proc.on('close', (code) => {
-      const combinedOutput = (output + errorOutput).trim();
+      const combinedOutput = (output).trim();
+      const metadata = {
+        taskType: 'exec',
+        exitCode: code,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      };
       
       if (code === 0) {
         printer.finish(cmd);
-        resolve(TaskResult.success(combinedOutput));
+        resolve(TaskResult.success(combinedOutput, metadata));
       } else {
         printer.error(cmd, new Error(`Exit code: ${code}`));
-        resolve(TaskResult.fail(combinedOutput));
+        resolve(TaskResult.fail(combinedOutput, metadata));
       }
     });
     
     proc.on('error', (error) => {
       printer.error(cmd, error);
-      resolve(TaskResult.fail(error.message));
+      resolve(TaskResult.fail(error.message, { taskType: 'exec' }));
     });
   });
 }

package/src/tasks/fetch.js

@@ -28,21 +28,29 @@ export default async function httpFetch() {
       }
     }
 
+    const metadata = {
+      taskType: 'fetch',
+      response: response.clone(), // Clone to allow json() to be called later
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries())
+    };
+
     if (response.ok) {
       printer.finish(taskName, { status: `${response.status} ${response.statusText}` });
       finishTaskInfo(taskInfo, true, null, output.trim());
-      return TaskResult.success(output.trim());
+      return TaskResult.success(output.trim(), metadata);
     } else {
       const errorMsg = `HTTP ${response.status} ${response.statusText}`;
       const error = new Error(errorMsg);
       printer.error(taskName, errorMsg);
       finishTaskInfo(taskInfo, false, error, errorMsg);
-      return TaskResult.fail(errorMsg);
+      return TaskResult.fail(errorMsg, metadata);
     }
     
   } catch (error) {
     printer.error(taskName, error);
     finishTaskInfo(taskInfo, false, error, error.message);
-    return TaskResult.fail(error.message);
+    return TaskResult.fail(error.message, { taskType: 'fetch' });
   }
 }

package/src/tasks/shell.js

@@ -81,9 +81,16 @@ export default function shell(strings, ...values) {
         
         const output = await result.text();
         
+        const metadata = {
+          taskType: 'shell',
+          exitCode: 0,
+          stdout: output.trim(),
+          stderr: ''
+        };
+        
         printer.finish(cmd);
         finishTaskInfo(taskInfo, true, null, output.trim());
-        resolve(TaskResult.success(output.trim()));
+        resolve(TaskResult.success(output.trim(), metadata));
         return;
         
       } catch (shellError) {
@@ -118,22 +125,29 @@ export default function shell(strings, ...values) {
             }
           }
           
+          const metadata = {
+            taskType: 'shell',
+            exitCode: shellError.exitCode,
+            stdout: stdout.trim(),
+            stderr: stderr.trim()
+          };
+          
           const error = new Error(`Exit code: ${shellError.exitCode}`);
           printer.error(cmd, null, { exitCode: shellError.exitCode });
           finishTaskInfo(taskInfo, false, error, errorOutput);
-          resolve(TaskResult.fail(errorOutput));
+          resolve(TaskResult.fail(errorOutput, metadata));
           return;
         } else {
           const errorMessage = shellError.message || shellError.toString();
           printer.error(cmd, shellError);
           finishTaskInfo(taskInfo, false, shellError, errorMessage);
-          resolve(TaskResult.fail(errorMessage));
+          resolve(TaskResult.fail(errorMessage, { taskType: 'shell' }));
         }
       }
     } catch (error) {
       printer.error(cmd, error);
       finishTaskInfo(taskInfo, false, error, error.message);
-      resolve(TaskResult.fail(error.message));
+      resolve(TaskResult.fail(error.message, { taskType: 'shell' }));
     }
   });