bunosh 0.3.1 → 0.4.0

package/src/task.js

@@ -1,17 +1,21 @@
 import { AsyncLocalStorage } from 'async_hooks';
 import Printer from './printer.js';
 
-export const TaskStatus = {
+// Use global objects created in bunosh.js
+export const TaskStatus = globalThis._bunoshGlobalTaskStatus || {
   RUNNING: 'running',
   FAIL: 'fail',
-  SUCCESS: 'success'
+  SUCCESS: 'success',
+  WARNING: 'warning'
 };
 
+// Initialize local array and also keep global synced
 export const tasksExecuted = [];
 export const runningTasks = new Map();
 
 let taskCounter = 0;
 let stopFailToggle = true;
+let globalSilenceMode = false;
 const asyncLocalStorage = new AsyncLocalStorage();
 
 
@@ -23,20 +27,29 @@ export function ignoreFail(enable = true) {
   stopFailToggle = !enable;
 }
 
-const startTime = Date.now();
+// Global failure mode control
+// true = stop on failures (exit with code 1), false = continue on failures
+let stopOnFailuresMode = false;
 
-process.on('exit', (code) => {
-  if (!process.env.BUNOSH_COMMAND_STARTED) return;
+export function ignoreFailures() {
+  stopOnFailuresMode = false;
+}
 
-  const totalTime = Date.now() - startTime;
-  const success = code === 0;
-  const tasksFailed = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.FAIL).length;
+export function stopOnFailures() {
+  stopOnFailuresMode = true;
+}
 
-  console.log(`\n🍲 ${success ? '' : 'FAIL '}Exit Code: ${code} | Tasks: ${tasksExecuted.length}${tasksFailed ? ` | Failed: ${tasksFailed}` : ''} | Time: ${totalTime}ms`);
-});
+export function silence() {
+  globalSilenceMode = true;
+}
+
+export function prints() {
+  globalSilenceMode = false;
+}
 
 export function getRunningTaskCount() {
-  return runningTasks.size;
+  // Only count top-level tasks (tasks without a parent)
+  return Array.from(runningTasks.values()).filter(task => !task.parentId).length;
 }
 
 export function getCurrentTaskId() {
@@ -44,14 +57,32 @@ export function getCurrentTaskId() {
 }
 
 export function getTaskPrefix(taskId) {
-  const taskNumber = Array.from(runningTasks.keys()).indexOf(taskId) + 1;
+  const taskInfo = runningTasks.get(taskId);
+  if (!taskInfo) return '';
+
+  // Only show prefixes for top-level tasks when there are multiple top-level tasks
+  if (taskInfo.parentId) {
+    // This is a child task, never show prefix
+    return '';
+  }
+
+  // For top-level tasks, calculate position among other top-level tasks
+  const topLevelTasks = Array.from(runningTasks.values()).filter(task => !task.parentId);
+  const taskNumber = topLevelTasks.findIndex(task => task.id === taskId) + 1;
   return getRunningTaskCount() > 1 ? `❰${taskNumber}❱` : '';
 }
 
-export function createTaskInfo(name) {
-  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
+
+export function createTaskInfo(name, parentId = null) {
+  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING, parentId);
   runningTasks.set(taskInfo.id, taskInfo);
   tasksExecuted.push(taskInfo);
+
+  // Also add to global array for exit handler
+  if (globalThis._bunoshGlobalTasksExecuted) {
+    globalThis._bunoshGlobalTasksExecuted.push(taskInfo);
+  }
+
   return taskInfo;
 }
 
@@ -70,27 +101,69 @@ export function finishTaskInfo(taskInfo, success = true, error = null, output =
 }
 
 export class TaskInfo {
-  constructor(name, startTime, status) {
+  constructor(name, startTime, status, parentId = null) {
     this.id = `task-${++taskCounter}-${Math.random().toString(36).substring(7)}`;
     this.name = name;
     this.startTime = startTime;
     this.status = status;
+    this.parentId = parentId;
   }
 }
 
-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);
+  const taskInfo = createTaskInfo(name);
 
-  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();
+  }
+
+  const taskInfo = createTaskInfo(name);
+
+  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 () => {
@@ -100,6 +173,11 @@ export async function task(name, fn) {
     const endTime = Date.now();
     const duration = endTime - taskInfo.startTime;
 
+    // Check if result is a TaskResult instance
+    if (result && result.constructor && result.constructor.name === 'TaskResult') {
+      return result;
+    }
+
     taskInfo.status = TaskStatus.SUCCESS;
     taskInfo.duration = duration;
     taskInfo.result = { status: TaskStatus.SUCCESS, output: result };
@@ -122,16 +200,51 @@ export async function task(name, fn) {
     // 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);
     }
-
+    
     throw err;
   }
 }
 
+// Add try method to task function
+task.try = tryTask;
+
+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 +259,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 +270,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/exec.js

@@ -1,9 +1,20 @@
-import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId } from '../task.js';
 import Printer from '../printer.js';
 
 const isBun = typeof Bun !== 'undefined';
 
 export default function exec(strings, ...values) {
+  // Check if called as regular function instead of template literal
+  if (!Array.isArray(strings)) {
+    // If first argument is a string, treat it as the command
+    if (typeof strings === 'string') {
+      strings = [strings];
+      values = [];
+    } else {
+      throw new Error('exec() must be called as a template literal: exec`command` or exec("command")');
+    }
+  }
+  
   const cmd = strings.reduce((accumulator, str, i) => {
     return accumulator + str + (values[i] || '');
   }, '');
@@ -16,7 +27,8 @@ export default function exec(strings, ...values) {
     if (cwd) extraInfo.cwd = cwd;
     if (envs) extraInfo.env = envs;
 
-    const taskInfo = createTaskInfo(cmd);
+    const currentTaskId = getCurrentTaskId();
+    const taskInfo = createTaskInfo(cmd, currentTaskId);
     const printer = new Printer('exec', taskInfo.id);
     printer.start(cmd, extraInfo);
 

package/src/tasks/fetch.js

@@ -1,4 +1,4 @@
-import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId } from '../task.js';
 import Printer from '../printer.js';
 
 export default async function httpFetch() {
@@ -6,7 +6,8 @@ export default async function httpFetch() {
   const method = arguments[1]?.method || 'GET';
   const taskName = `${method} ${url}`;
   
-  const taskInfo = createTaskInfo(taskName);
+  const currentTaskId = getCurrentTaskId();
+  const taskInfo = createTaskInfo(taskName, currentTaskId);
   const printer = new Printer('fetch', taskInfo.id);
   printer.start(taskName);
 
@@ -20,7 +21,7 @@ export default async function httpFetch() {
         const lines = textDecoder.decode(chunk, { stream: true }).toString().split('\n');
         for (const line of lines) {
           if (line.trim()) {
-            printer.print(line, 'output');
+            printer.output(line);
             output += line + '\n';
           }
         }

package/src/tasks/shell.js

@@ -4,13 +4,45 @@ import Printer from "../printer.js";
 const isBun = typeof Bun !== 'undefined' && typeof Bun.spawn === 'function';
 
 export default function shell(strings, ...values) {
+  let envs = null;
+  let cwd = null;
+  
+  // Check if called as regular function instead of template literal
+  if (!Array.isArray(strings)) {
+    // If first argument is a string, treat it as the command
+    if (typeof strings === 'string') {
+      // For Bun shell, we need to create a template literal-like call
+      // But since we can't, fall back to exec
+      console.log('Note: shell() with string argument falls back to exec()');
+      const cmdPromise = (async () => {
+        const { default: exec } = await import("./exec.js");
+        let execPromise = exec(strings);
+        if (envs) execPromise = execPromise.env(envs);
+        if (cwd) execPromise = execPromise.cwd(cwd);
+        return execPromise;
+      })();
+      
+      // Add .env and .cwd methods
+      cmdPromise.env = (newEnvs) => {
+        envs = newEnvs;
+        return cmdPromise;
+      };
+      
+      cmdPromise.cwd = (newCwd) => {
+        cwd = newCwd;
+        return cmdPromise;
+      };
+      
+      return cmdPromise;
+    } else {
+      throw new Error('shell() must be called as a template literal: shell`command`');
+    }
+  }
+  
   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;
@@ -18,7 +50,7 @@ export default function shell(strings, ...values) {
 
     if (!isBun) {
       const { default: exec } = await import("./exec.js");
-      let execPromise = exec(strings, ...values);
+      let execPromise = exec([cmd]);
       if (envs) execPromise = execPromise.env(envs);
       if (cwd) execPromise = execPromise.cwd(cwd);
       const result = await execPromise;
@@ -64,7 +96,7 @@ export default function shell(strings, ...values) {
           finishTaskInfo(taskInfo, true, null, "fallback to exec");
           
           const { default: exec } = await import("./exec.js");
-          let execPromise = exec`${cmd}`;
+          let execPromise = exec([cmd]);
           if (envs) execPromise = execPromise.env(envs);
           if (cwd) execPromise = execPromise.cwd(cwd);
           const result = await execPromise;

package/src/open-editor.js

@@ -1,95 +0,0 @@
-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;
-}