bunosh 0.3.0 → 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

@@ -1,32 +1,41 @@
 import exec from "./src/tasks/exec.js";
+import shell from "./src/tasks/shell.js";
 import fetch from "./src/tasks/fetch.js";
 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";
-
-export { exec, fetch, writeToFile, copyFile, ai, ask, yell, say, task, stopOnFail, ignoreFail };
+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, tryTask, stopOnFail, ignoreFail, stopOnFailures, ignoreFailures, silence, prints, silent };
 
 export function buildCmd(cmd) {
-  return function(args) {
-    return exec`${cmd} ${args}`
-  }
+  return function (args) {
+    return exec`${cmd} ${args}`;
+  };
 }
 
 global.bunosh = {
-  ask, yell, say,
+  ask,
+  yell,
+  say,
   fetch,
   exec,
+  shell,
   writeToFile,
   copyFile,
   ai,
   stopOnFail,
   ignoreFail,
   task,
+  try: tryTask,
+  stopOnFailures,
+  ignoreFailures,
+  silence,
+  prints,
+  silent,
   buildCmd,
   $: exec,
-}
+};
 
 export default global.bunosh;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "module": "index.js",
   "bin": {
@@ -25,7 +25,6 @@
     "debug": "^4.4.1",
     "fs-extra": "^11.3.0",
     "inquirer": "^12.6.3",
-    "open-editor": "^5.1.0",
     "timer-node": "^5.0.9",
     "zod": "^4.1.5"
   },

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/io.js

@@ -6,11 +6,65 @@ export function say(...args) {
   console.log('!', ...args);
 }
 
-export async function ask(question, opts = {}) {
+export async function ask(question, defaultValueOrOptions = {}, options = {}) {
+  // Smart parameter detection
+  let opts = {};
+  
+  // If second parameter is not an object, it's a default value
+  if (defaultValueOrOptions !== null && typeof defaultValueOrOptions !== 'object') {
+    opts.default = defaultValueOrOptions;
+    opts = { ...opts, ...options }; // Merge with third parameter options
+    
+    // Auto-detect type based on default value
+    if (typeof defaultValueOrOptions === 'boolean') {
+      opts.type = 'confirm';
+    }
+  } else if (Array.isArray(defaultValueOrOptions)) {
+    // If it's an array, treat as choices
+    opts.choices = defaultValueOrOptions;
+    opts = { ...opts, ...options }; // Merge with third parameter options
+  } else {
+    // Traditional object parameter
+    opts = { ...defaultValueOrOptions, ...options };
+  }
+  
+  // Route to appropriate handler based on options
+  if (opts.editor || opts.multiline) {
+    return await askWithEditor(question, opts);
+  }
+  
+  if (opts.choices) {
+    return await askWithChoices(question, opts);
+  }
+  
   const answers = await inquirer.prompt({ name: question, message: question, ...opts })
   return Object.values(answers)[0];
 }
 
+async function askWithEditor(question, opts = {}) {
+  const answers = await inquirer.prompt({
+    name: question,
+    message: question,
+    type: 'editor',
+    ...opts
+  });
+  return Object.values(answers)[0];
+}
+
+async function askWithChoices(question, opts = {}) {
+  const promptType = opts.multiple ? 'checkbox' : 'list';
+  
+  const answers = await inquirer.prompt({
+    name: question,
+    message: question,
+    type: promptType,
+    choices: opts.choices,
+    ...opts
+  });
+  
+  return Object.values(answers)[0];
+}
+
 export function yell(text) {
   console.log();
 

package/src/open-editor.js

@@ -0,0 +1,95 @@
+import { spawn } from 'child_process';
+import path from 'path';
+
+export default function openEditor(files, options = {}) {
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new Error('Files array is required and cannot be empty');
+  }
+
+  const editor = options.editor || getDefaultEditor();
+  const fileArgs = buildEditorArgs(editor, files);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(editor, fileArgs, {
+      stdio: 'inherit',
+      detached: true
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(`Failed to open editor '${editor}': ${err.message}`));
+    });
+
+    child.on('spawn', () => {
+      resolve();
+    });
+
+    if (child.pid) {
+      child.unref();
+    }
+  });
+}
+
+function getDefaultEditor() {
+  if (process.env.EDITOR) {
+    return process.env.EDITOR;
+  }
+
+  const editors = ['code', 'subl', 'atom', 'vim', 'nvim', 'nano', 'gedit'];
+  
+  for (const editor of editors) {
+    if (isCommandAvailable(editor)) {
+      return editor;
+    }
+  }
+
+  return process.platform === 'win32' ? 'notepad' : 'vi';
+}
+
+function isCommandAvailable(command) {
+  try {
+    const { execSync } = require('child_process');
+    execSync(`which ${command}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function buildEditorArgs(editor, files) {
+  const editorName = path.basename(editor);
+  const args = [];
+
+  for (const fileInfo of files) {
+    const filePath = typeof fileInfo === 'string' ? fileInfo : fileInfo.file;
+    
+    if (!filePath) {
+      continue;
+    }
+
+    if (fileInfo.line && typeof fileInfo === 'object') {
+      switch (editorName) {
+        case 'code':
+        case 'code-insiders':
+          args.push('--goto', `${filePath}:${fileInfo.line}:${fileInfo.column || 1}`);
+          break;
+        case 'subl':
+        case 'sublime_text':
+          args.push(`${filePath}:${fileInfo.line}:${fileInfo.column || 1}`);
+          break;
+        case 'vim':
+        case 'nvim':
+          args.push(`+${fileInfo.line}`, filePath);
+          break;
+        case 'nano':
+          args.push(`+${fileInfo.line}`, filePath);
+          break;
+        default:
+          args.push(filePath);
+      }
+    } else {
+      args.push(filePath);
+    }
+  }
+
+  return args;
+}

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/program.js

@@ -4,7 +4,7 @@ import traverseDefault from "@babel/traverse";
 const traverse = traverseDefault.default || traverseDefault;
 import color from "chalk";
 import fs from 'fs';
-import openEditor from 'open-editor';
+import openEditor from './open-editor.js';
 import { yell } from './io.js';
 import cprint from "./font.js";
 import { handleCompletion, detectCurrentShell, installCompletion, getCompletionPaths } from './completion.js';
@@ -251,12 +251,16 @@ export default function bunosh(commands, source) {
 
   const editCmd = program.command('edit')
     .description('Open the bunosh file in your editor. $EDITOR or \'code\' is used.')
-    .action(() => {
-      openEditor([{
-        file: BUNOSHFILE,
-      }], {
-        editor: process.env.EDITOR ? null : 'code',
-      });
+    .action(async () => {
+      try {
+        await openEditor([{
+          file: BUNOSHFILE,
+        }]);
+      } catch (error) {
+        console.error(error.message);
+        console.error('Set $EDITOR environment variable to use a different editor');
+        process.exit(1);
+      }
     });
 
   internalCommands.push(editCmd);

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 });
+  }
 }

package/src/tasks/shell.js

@@ -0,0 +1,119 @@
+import { TaskResult, createTaskInfo, finishTaskInfo } from "../task.js";
+import Printer from "../printer.js";
+
+const isBun = typeof Bun !== 'undefined' && typeof Bun.spawn === 'function';
+
+export default function shell(strings, ...values) {
+  const cmd = strings.reduce((accumulator, str, i) => {
+    return accumulator + str + (values[i] || "");
+  }, "");
+
+  let envs = null;
+  let cwd = null;
+
+  const cmdPromise = new Promise(async (resolve, reject) => {
+    const extraInfo = {};
+    if (cwd) extraInfo.cwd = cwd;
+    if (envs) extraInfo.env = envs;
+
+    if (!isBun) {
+      const { default: exec } = await import("./exec.js");
+      let execPromise = exec(strings, ...values);
+      if (envs) execPromise = execPromise.env(envs);
+      if (cwd) execPromise = execPromise.cwd(cwd);
+      const result = await execPromise;
+      resolve(result);
+      return;
+    }
+
+    const taskInfo = createTaskInfo(cmd);
+    const printer = new Printer("shell", taskInfo.id);
+    printer.start(cmd, extraInfo);
+
+    try {
+      const { $ } = await import("bun");
+      
+      let shell = $;
+      
+      if (cwd) {
+        shell = shell.cwd(cwd);
+      }
+      
+      if (envs) {
+        shell = shell.env(envs);
+      }
+
+      let result;
+      try {
+        result = await shell(strings, ...values);
+        
+        const output = await result.text();
+        
+        printer.finish(cmd);
+        finishTaskInfo(taskInfo, true, null, output.trim());
+        resolve(TaskResult.success(output.trim()));
+        return;
+        
+      } catch (shellError) {
+        const isCommandNotFound = shellError.stderr && 
+          (shellError.stderr.includes('command not found') || 
+           shellError.stderr.includes('bun: command not found'));
+        
+        if (isCommandNotFound) {
+          printer.finish(cmd);
+          finishTaskInfo(taskInfo, true, null, "fallback to exec");
+          
+          const { default: exec } = await import("./exec.js");
+          let execPromise = exec`${cmd}`;
+          if (envs) execPromise = execPromise.env(envs);
+          if (cwd) execPromise = execPromise.cwd(cwd);
+          const result = await execPromise;
+          resolve(result);
+          return;
+        }
+        
+        if (shellError.exitCode !== undefined) {
+          const stderr = shellError.stderr ? Buffer.isBuffer(shellError.stderr) ? shellError.stderr.toString() : shellError.stderr : "";
+          const stdout = shellError.stdout ? Buffer.isBuffer(shellError.stdout) ? shellError.stdout.toString() : shellError.stdout : "";
+          const errorOutput = (stderr + stdout).trim() || `Command failed with exit code ${shellError.exitCode}`;
+          
+          if (errorOutput) {
+            const lines = errorOutput.split('\n');
+            for (const line of lines) {
+              if (line.trim()) {
+                printer.output(line, true);
+              }
+            }
+          }
+          
+          const error = new Error(`Exit code: ${shellError.exitCode}`);
+          printer.error(cmd, null, { exitCode: shellError.exitCode });
+          finishTaskInfo(taskInfo, false, error, errorOutput);
+          resolve(TaskResult.fail(errorOutput));
+          return;
+        } else {
+          const errorMessage = shellError.message || shellError.toString();
+          printer.error(cmd, shellError);
+          finishTaskInfo(taskInfo, false, shellError, errorMessage);
+          resolve(TaskResult.fail(errorMessage));
+        }
+      }
+    } catch (error) {
+      printer.error(cmd, error);
+      finishTaskInfo(taskInfo, false, error, error.message);
+      resolve(TaskResult.fail(error.message));
+    }
+  });
+
+  cmdPromise.env = (newEnvs) => {
+    envs = newEnvs;
+    return cmdPromise;
+  };
+
+  cmdPromise.cwd = (newCwd) => {
+    cwd = newCwd;
+    return cmdPromise;
+  };
+
+  return cmdPromise;
+}