bunosh 0.3.1 → 0.3.2

package/bunosh.js

@@ -60,6 +60,30 @@ import(tasksFile).then((tasks) => {
   handleBunoshfileError(error, tasksFile);
 });
 
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (reason, promise) => {
+  if (!process.env.BUNOSH_COMMAND_STARTED) return;
+  
+  console.error('\n❌ Unhandled Promise Rejection:');
+  console.error(reason instanceof Error ? reason.message : reason);
+  if (reason instanceof Error && reason.stack && process.env.BUNOSH_DEBUG) {
+    console.error(reason.stack);
+  }
+  process.exit(1);
+});
+
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+  if (!process.env.BUNOSH_COMMAND_STARTED) return;
+  
+  console.error('\n❌ Uncaught Exception:');
+  console.error(error.message);
+  if (error.stack && process.env.BUNOSH_DEBUG) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+
 function handleBunoshfileError(error, filePath) {
   banner();
   console.log();

package/index.js

@@ -5,9 +5,9 @@ import writeToFile from "./src/tasks/writeToFile.js";
 import copyFile from "./src/tasks/copyFile.js";
 import ai from "./src/tasks/ai.js";
 import { ask, yell, say } from "./src/io.js";
-import { task, stopOnFail, ignoreFail } from "./src/task.js";
+import { task, tryTask, stopOnFail, ignoreFail, stopOnFailures, ignoreFailures, silence, prints, silent } from "./src/task.js";
 
-export { exec, shell, fetch, writeToFile, copyFile, ai, ask, yell, say, task, stopOnFail, ignoreFail };
+export { exec, shell, fetch, writeToFile, copyFile, ai, ask, yell, say, task, tryTask, stopOnFail, ignoreFail, stopOnFailures, ignoreFailures, silence, prints, silent };
 
 export function buildCmd(cmd) {
   return function (args) {
@@ -28,6 +28,12 @@ global.bunosh = {
   stopOnFail,
   ignoreFail,
   task,
+  try: tryTask,
+  stopOnFailures,
+  ignoreFailures,
+  silence,
+  prints,
+  silent,
   buildCmd,
   $: exec,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "module": "index.js",
   "bin": {

package/src/formatters/console.js

@@ -5,6 +5,7 @@ const STATUS_CONFIG = {
   start: { icon: '▶', color: 'blue' },
   finish: { icon: '✓', color: 'green' },
   error: { icon: '✗', color: 'red' },
+  warning: { icon: '⚠', color: 'yellow' },
   output: { icon: ' ', color: 'white' },
   info: { icon: ' ', color: 'dim' }
 };

package/src/formatters/github-actions.js

@@ -22,6 +22,10 @@ export class GitHubActionsFormatter extends BaseFormatter {
         const errorDetails = extra.error ? ` - ${extra.error}` : '';
         return `::endgroup::\n::error::❌ ${fullTaskName}${errorDetails}`;
         
+      case 'warning':
+        const warningDetails = extra.error ? ` - ${extra.error}` : '';
+        return `::endgroup::\n::warning::⚠️ ${fullTaskName}${warningDetails}`;
+        
       case 'output':
         return taskName;
         

package/src/printer.js

@@ -65,6 +65,17 @@ export class Printer {
     this.print(taskName, 'error', extra);
   }
 
+  warning(taskName, error = null, extra = {}) {
+    if (this.startTimeout) {
+      clearTimeout(this.startTimeout);
+      this.startTimeout = null;
+    }
+    if (error) {
+      extra.error = typeof error === 'string' ? error : error.message;
+    }
+    this.print(taskName, 'warning', extra);
+  }
+
   output(line, isError = false) {
     if (!line.trim()) return;
 

package/src/task.js

@@ -4,7 +4,8 @@ import Printer from './printer.js';
 export const TaskStatus = {
   RUNNING: 'running',
   FAIL: 'fail',
-  SUCCESS: 'success'
+  SUCCESS: 'success',
+  WARNING: 'warning'
 };
 
 export const tasksExecuted = [];
@@ -12,6 +13,7 @@ export const runningTasks = new Map();
 
 let taskCounter = 0;
 let stopFailToggle = true;
+let globalSilenceMode = false;
 const asyncLocalStorage = new AsyncLocalStorage();
 
 
@@ -23,16 +25,50 @@ export function ignoreFail(enable = true) {
   stopFailToggle = !enable;
 }
 
+// Global failure mode control
+// true = stop on failures (exit with code 1), false = continue on failures
+let stopOnFailuresMode = false;
+
+export function ignoreFailures() {
+  stopOnFailuresMode = false;
+}
+
+export function stopOnFailures() {
+  stopOnFailuresMode = true;
+}
+
+export function silence() {
+  globalSilenceMode = true;
+}
+
+export function prints() {
+  globalSilenceMode = false;
+}
+
 const startTime = Date.now();
 
 process.on('exit', (code) => {
   if (!process.env.BUNOSH_COMMAND_STARTED) return;
 
   const totalTime = Date.now() - startTime;
-  const success = code === 0;
   const tasksFailed = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.FAIL).length;
+  const tasksWarning = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.WARNING).length;
+  
+  // Check if we're in test environment
+  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:'));
+  
+  // Set exit code to 1 if any tasks failed AND we're not in ignoreFailures mode AND not in test environment
+  // Note: if stopOnFailuresMode is true, we would have already exited immediately
+  if (tasksFailed > 0 && !stopOnFailuresMode && !isTestEnvironment) {
+    process.exitCode = 1;
+  }
+  
+  const finalExitCode = (tasksFailed > 0 && !stopOnFailuresMode && !isTestEnvironment) ? 1 : code;
+  const success = finalExitCode === 0;
 
-  console.log(`\n🍲 ${success ? '' : 'FAIL '}Exit Code: ${code} | Tasks: ${tasksExecuted.length}${tasksFailed ? ` | Failed: ${tasksFailed}` : ''} | Time: ${totalTime}ms`);
+  console.log(`\n🍲 ${success ? '' : 'FAIL '}Exit Code: ${finalExitCode} | Tasks: ${tasksExecuted.length}${tasksFailed ? ` | Failed: ${tasksFailed}` : ''}${tasksWarning ? ` | Warnings: ${tasksWarning}` : ''} | Time: ${totalTime}ms`);
 });
 
 export function getRunningTaskCount() {
@@ -78,7 +114,53 @@ export class TaskInfo {
   }
 }
 
-export async function task(name, fn) {
+export async function tryTask(name, fn, isSilent = false) {
+  if (!fn) {
+    fn = name;
+    name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
+  }
+
+  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
+
+  tasksExecuted.push(taskInfo);
+  runningTasks.set(taskInfo.id, taskInfo);
+
+  const shouldPrint = !globalSilenceMode && !isSilent;
+  const printer = new Printer('task', taskInfo.id);
+  if (shouldPrint) printer.start(name);
+
+  try {
+    const result = await asyncLocalStorage.run(taskInfo.id, async () => {
+      return await Promise.resolve(fn());
+    });
+
+    const endTime = Date.now();
+    const duration = endTime - taskInfo.startTime;
+
+    taskInfo.status = TaskStatus.SUCCESS;
+    taskInfo.duration = duration;
+    taskInfo.result = { status: TaskStatus.SUCCESS, output: result };
+
+    if (shouldPrint) printer.finish(name);
+    runningTasks.delete(taskInfo.id);
+
+    return true;
+  } catch (err) {
+    const endTime = Date.now();
+    const duration = endTime - taskInfo.startTime;
+
+    taskInfo.status = TaskStatus.WARNING;
+    taskInfo.duration = duration;
+    taskInfo.result = { status: TaskStatus.WARNING, output: err.message };
+
+    if (shouldPrint) printer.warning(name, err);
+    runningTasks.delete(taskInfo.id);
+
+    return false;
+  }
+}
+
+export async function task(name, fn, isSilent = false) {
   if (!fn) {
     fn = name;
     name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
@@ -89,8 +171,9 @@ export async function task(name, fn) {
   tasksExecuted.push(taskInfo);
   runningTasks.set(taskInfo.id, taskInfo);
 
+  const shouldPrint = !globalSilenceMode && !isSilent;
   const printer = new Printer('task', taskInfo.id);
-  printer.start(name);
+  if (shouldPrint) printer.start(name);
 
   try {
     const result = await asyncLocalStorage.run(taskInfo.id, async () => {
@@ -104,7 +187,7 @@ export async function task(name, fn) {
     taskInfo.duration = duration;
     taskInfo.result = { status: TaskStatus.SUCCESS, output: result };
 
-    printer.finish(name);
+    if (shouldPrint) printer.finish(name);
     runningTasks.delete(taskInfo.id);
 
     return result;
@@ -116,14 +199,20 @@ export async function task(name, fn) {
     taskInfo.duration = duration;
     taskInfo.result = { status: TaskStatus.FAIL, output: err.message };
 
-    printer.error(name, err);
+    if (shouldPrint) printer.error(name, err);
     runningTasks.delete(taskInfo.id);
 
     // Don't exit during testing
     const isTestEnvironment = process.env.NODE_ENV === 'test' ||
                               typeof Bun?.jest !== 'undefined' ||
-                              process.argv.some(arg => arg.includes('test'));
+                              process.argv.some(arg => arg.includes('vitest') || arg.includes('jest') || arg.includes('--test') || arg.includes('test:'));
 
+    // Exit immediately if stopOnFailures mode is enabled
+    if (stopOnFailuresMode && !isTestEnvironment) {
+      process.exit(1);
+    }
+    
+    // Also exit if stopFailToggle is enabled (legacy behavior)
     if (stopFailToggle && !isTestEnvironment) {
       process.exit(1);
     }
@@ -132,6 +221,32 @@ export async function task(name, fn) {
   }
 }
 
+export class SilentTaskWrapper {
+  constructor() {
+    this.silent = true;
+  }
+
+  async try(name, fn) {
+    if (!fn) {
+      fn = name;
+      name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
+    }
+    return await tryTask(name, fn, true);
+  }
+
+  async task(name, fn) {
+    if (!fn) {
+      fn = name;
+      name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
+    }
+    return await task(name, fn, true);
+  }
+}
+
+export function silent() {
+  return new SilentTaskWrapper();
+}
+
 export class TaskResult {
   constructor({ status, output }) {
     this.status = status;
@@ -146,6 +261,10 @@ export class TaskResult {
     return this.status === TaskStatus.SUCCESS;
   }
 
+  get hasWarning() {
+    return this.status === TaskStatus.WARNING;
+  }
+
   static fail(output = null) {
     return new TaskResult({ status: TaskStatus.FAIL, output });
   }
@@ -153,4 +272,8 @@ export class TaskResult {
   static success(output = null) {
     return new TaskResult({ status: TaskStatus.SUCCESS, output });
   }
+
+  static warning(output = null) {
+    return new TaskResult({ status: TaskStatus.WARNING, output });
+  }
 }