bunosh 0.3.2 → 0.4.1

package/bunosh.js

@@ -1,63 +1,147 @@
 #!/usr/bin/env bun
+
+// Set up global variables BEFORE any imports
+globalThis._bunoshStartTime = Date.now();
+globalThis._bunoshCommandCompleted = false;
+globalThis._bunoshGlobalTasksExecuted = [];
+globalThis._bunoshGlobalTaskStatus = {
+  RUNNING: 'running',
+  FAIL: 'fail',
+  SUCCESS: 'success',
+  WARNING: 'warning'
+};
+
+// Now import modules
+
 import program, { BUNOSHFILE, banner }  from "./src/program.js";
 import { existsSync, readFileSync, statSync } from "fs";
 import init from "./src/init.js";
 import path from "path";
-import color from "chalk";
-import './index.js';
-
-// Parse --bunoshfile flag before importing tasks
-const bunoshfileIndex = process.argv.indexOf('--bunoshfile');
-let customBunoshfile = null;
-if (bunoshfileIndex !== -1 && bunoshfileIndex + 1 < process.argv.length) {
-  customBunoshfile = process.argv[bunoshfileIndex + 1];
-  // Remove the flag and its value from process.argv so it doesn't interfere with command parsing
-  process.argv.splice(bunoshfileIndex, 2);
-}
 
-let tasksFile;
-if (customBunoshfile) {
-  const resolvedPath = path.isAbsolute(customBunoshfile) ? customBunoshfile : path.resolve(customBunoshfile);
-  // If it's a directory, append the default BUNOSHFILE
-  if (existsSync(resolvedPath) && statSync(resolvedPath).isDirectory()) {
-    tasksFile = path.join(resolvedPath, BUNOSHFILE);
-    // Change working directory to the bunoshfile directory
-    process.chdir(resolvedPath);
+
+async function main() {
+
+  // Parse --bunoshfile flag before importing tasks
+  const bunoshfileIndex = process.argv.indexOf('--bunoshfile');
+  let customBunoshfile = null;
+  if (bunoshfileIndex !== -1 && bunoshfileIndex + 1 < process.argv.length) {
+    customBunoshfile = process.argv[bunoshfileIndex + 1];
+    // Remove the flag and its value from process.argv so it doesn't interfere with command parsing
+    process.argv.splice(bunoshfileIndex, 2);
+  }
+
+  let tasksFile;
+  if (customBunoshfile) {
+    const resolvedPath = path.isAbsolute(customBunoshfile) ? customBunoshfile : path.resolve(customBunoshfile);
+    // If it's a directory, append the default BUNOSHFILE
+    if (existsSync(resolvedPath) && statSync(resolvedPath).isDirectory()) {
+      tasksFile = path.join(resolvedPath, BUNOSHFILE);
+      // Change working directory to the bunoshfile directory
+      process.chdir(resolvedPath);
+    } else {
+      tasksFile = resolvedPath;
+      // Change working directory to the bunoshfile's directory
+      process.chdir(path.dirname(resolvedPath));
+    }
   } else {
-    tasksFile = resolvedPath;
-    // Change working directory to the bunoshfile's directory
-    process.chdir(path.dirname(resolvedPath));
+    tasksFile = path.join(process.cwd(), BUNOSHFILE);
+  }
+
+  // Handle -e flag for executing JavaScript code
+  const eFlagIndex = process.argv.indexOf('-e');
+  if (eFlagIndex !== -1) {
+    let jsCode = '';
+    
+    // Check if code is provided as argument
+    if (eFlagIndex + 1 < process.argv.length && !process.argv[eFlagIndex + 1].startsWith('-')) {
+      jsCode = process.argv[eFlagIndex + 1];
+    } else if (!process.stdin.isTTY) {
+      // Read from stdin only if it's not a TTY (i.e., it's being piped)
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      jsCode = Buffer.concat(chunks).toString('utf8').trim();
+    }
+    
+    if (!jsCode) {
+      console.error('No JavaScript code provided');
+      process.exit(1);
+    }
+    
+    try {
+      // Import bunosh globals before executing JavaScript
+      await import('./index.js');
+      
+      // Make bunosh globals available to the function by creating wrapper functions
+      for (const [key, value] of Object.entries(global.bunosh)) {
+        if (typeof value === 'function') {
+          // For template literal tag functions like exec and shell, create a wrapper
+          // that allows them to be called as regular functions with a string
+          if (key === 'exec' || key === 'writeToFile') {
+            globalThis[key] = (str) => {
+              // If called as a regular function with a string, convert to template literal call
+              if (typeof str === 'string') {
+                return value([str]);
+              }
+              // Otherwise call normally
+              return value(str, ...Array.from(arguments).slice(1));
+            };
+          } else if (key === 'shell') {
+            // Shell function has special handling for string arguments - it falls back to exec
+            globalThis[key] = value;
+          } else {
+            globalThis[key] = value;
+          }
+        }
+      }
+      
+      // Execute the JavaScript code with bunosh globals available
+      const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+      const func = new AsyncFunction(jsCode);
+      await func();
+      return;
+    } catch (error) {
+      console.error('Error executing JavaScript:', error.message);
+      process.exit(1);
+    }
   }
-} else {
-  tasksFile = path.join(process.cwd(), BUNOSHFILE);
-}
 
-if (!existsSync(tasksFile)) {
-  banner();
+  if (!existsSync(tasksFile)) {
+    banner();
 
-  if (process.argv.includes('init')) {
-    init();
-    process.exit(0);
+    if (process.argv.includes('init')) {
+      init();
+      process.exit(0);
+    }
+
+    console.log();
+    console.error(`Bunoshfile not found: ${tasksFile}`);
+    console.log(customBunoshfile ? 
+      `Run \`bunosh init\` in the directory or specify a valid --bunoshfile path` :
+      "Run `bunosh init` to create a new Bunoshfile here")
+    console.log();
+    process.exit(1);
   }
 
-  console.log();
-  console.error(`Bunoshfile not found: ${tasksFile}`);
-  console.log(customBunoshfile ? 
-    `Run \`bunosh init\` in the directory or specify a valid --bunoshfile path` :
-    "Run `bunosh init` to create a new Bunoshfile here")
-  console.log();
-  process.exit(1);
+  // Import bunosh globals for normal operation
+  await import('./index.js');
+  
+  import(tasksFile).then(async (tasks) => {
+    try {
+      const source = readFileSync(tasksFile, "utf-8");
+      await program(tasks, source);
+    } catch (error) {
+      handleBunoshfileError(error, tasksFile);
+    }
+  }).catch((error) => {
+    handleBunoshfileError(error, tasksFile);
+  });
 }
 
-import(tasksFile).then((tasks) => {
-  try {
-    const source = readFileSync(tasksFile, "utf-8");
-    program(tasks, source);
-  } catch (error) {
-    handleBunoshfileError(error, tasksFile);
-  }
-}).catch((error) => {
-  handleBunoshfileError(error, tasksFile);
+main().catch((error) => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
 });
 
 // Handle unhandled promise rejections
@@ -84,9 +168,50 @@ process.on('uncaughtException', (error) => {
   process.exit(1);
 });
 
+// Handle exit for task summary
+process.on('exit', (code) => {
+  if (!process.env.BUNOSH_COMMAND_STARTED) return;
+  
+  // Don't print summary if exit was due to stdin closing during an ask operation
+  // This prevents duplicate output when ask commands don't receive all required input
+  if (globalThis._bunoshInAskOperation && code === 0) {
+    return;
+  }
+  
+  // Access global values directly
+  const tasksExecuted = globalThis._bunoshGlobalTasksExecuted || [];
+  const TaskStatus = globalThis._bunoshGlobalTaskStatus || { FAIL: 'fail', WARNING: 'warning' };
+  
+  // Calculate total time from when the process started
+  const totalTime = Date.now() - globalThis._bunoshStartTime || 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 test environment
+  if (tasksFailed > 0 && !isTestEnvironment) {
+    process.exitCode = 1;
+  }
+  
+  const finalExitCode = (tasksFailed > 0 && !isTestEnvironment) ? 1 : code;
+  const success = finalExitCode === 0;
+
+  // Debug: Check if this handler has already run
+  if (globalThis._bunoshExitHandlerCalled) {
+    console.log('\n[DEBUG] Exit handler already called, skipping duplicate');
+    return;
+  }
+  globalThis._bunoshExitHandlerCalled = true;
+
+  console.log(`\n🍲 ${success ? '' : 'FAIL '}Exit Code: ${finalExitCode} | Tasks: ${tasksExecuted.length}${tasksFailed ? ` | Failed: ${tasksFailed}` : ''}${tasksWarning ? ` | Warnings: ${tasksWarning}` : ''} | Time: ${totalTime}ms`);
+});
+
 function handleBunoshfileError(error, filePath) {
-  banner();
-  console.log();
+  // Don't show banner for errors - it interferes with error visibility
   
   // Check for Babel parser syntax errors
   if (error.code === 'BABEL_PARSER_SYNTAX_ERROR' || 

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

package/package.json

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

package/src/init.js

@@ -4,9 +4,9 @@ import fs from 'fs';
 
 const template = `
 // Bunosh CLI required to execute tasks from this file
-// Get it here -> https://github.com/DavertMik/bunosh/releases
+// Get it here => https://buno.sh
 
-const { exec, fetch, writeToFile, task, ai } = global.bunosh;
+const { exec, shell, fetch, writeToFile, task, ai } = global.bunosh;
 
 // input/output
 const { say, ask, yell } = global.bunosh;

package/src/io.js

@@ -7,6 +7,8 @@ export function say(...args) {
 }
 
 export async function ask(question, defaultValueOrOptions = {}, options = {}) {
+  // Track that we're in an ask operation to prevent duplicate exit summaries
+  globalThis._bunoshInAskOperation = true;
   // Smart parameter detection
   let opts = {};
   
@@ -37,38 +39,105 @@ export async function ask(question, defaultValueOrOptions = {}, options = {}) {
     return await askWithChoices(question, opts);
   }
   
-  const answers = await inquirer.prompt({ name: question, message: question, ...opts })
-  return Object.values(answers)[0];
+  try {
+    const answers = await inquirer.prompt({ name: question, message: question, ...opts })
+    return Object.values(answers)[0];
+  } finally {
+    // Reset ask operation flag
+    globalThis._bunoshInAskOperation = false;
+  }
 }
 
 async function askWithEditor(question, opts = {}) {
-  const answers = await inquirer.prompt({
-    name: question,
-    message: question,
-    type: 'editor',
-    ...opts
-  });
-  return Object.values(answers)[0];
+  globalThis._bunoshInAskOperation = true;
+  try {
+    const answers = await inquirer.prompt({
+      name: question,
+      message: question,
+      type: 'editor',
+      ...opts
+    });
+    return Object.values(answers)[0];
+  } finally {
+    globalThis._bunoshInAskOperation = false;
+  }
 }
 
 async function askWithChoices(question, opts = {}) {
+  globalThis._bunoshInAskOperation = true;
   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];
+  try {
+    const answers = await inquirer.prompt({
+      name: question,
+      message: question,
+      type: promptType,
+      choices: opts.choices,
+      ...opts
+    });
+    
+    return Object.values(answers)[0];
+  } finally {
+    globalThis._bunoshInAskOperation = false;
+  }
 }
 
 export function yell(text) {
-  console.log();
+  // Always use boxed capitalized format
+  const upperText = text.toUpperCase();
+  const boxText = createBoxedText(upperText);
+  console.log(boxText);
+}
 
-  console.log(chalk.bold.yellow(cprint(text, { symbol: '■' })));
+function createGradientAscii(asciiArt) {
+  const lines = asciiArt.split('\n');
+  const colors = [
+    chalk.bold.yellow,
+    chalk.bold.green,
+    chalk.bold.greenBright,
+    chalk.bold.cyan,
+    chalk.bold.blue
+  ];
+  
+  return lines.map((line, index) => {
+    // Create smooth gradient by interpolating between colors
+    const progress = index / (lines.length - 1);
+    const colorIndex = progress * (colors.length - 1);
+    const lowerIndex = Math.floor(colorIndex);
+    const upperIndex = Math.min(lowerIndex + 1, colors.length - 1);
+    const factor = colorIndex - lowerIndex;
+    
+    // For smoother transition, we'll use the closest color
+    const color = factor < 0.5 ? colors[lowerIndex] : colors[upperIndex];
+    return color(line);
+  }).join('\n');
+}
 
-  console.log();
+function createBoxedText(text) {
+  const maxLength = Math.max(text.length, 10);
+  const totalWidth = maxLength + 6; // 6 = 3 spaces padding on each side
+  const leftPadding = Math.floor((totalWidth - text.length) / 2);
+  const rightPadding = totalWidth - text.length - leftPadding;
+  
+  // Use Unicode box drawing characters for a nice look
+  const topLeft = '╭';
+  const topRight = '╮';
+  const bottomLeft = '╰';
+  const bottomRight = '╯';
+  const horizontal = '─';
+  const vertical = '│';
+  
+  const horizontalBorder = topLeft + horizontal.repeat(totalWidth) + topRight;
+  const emptyLine = vertical + ' '.repeat(totalWidth) + vertical;
+  const textLine = vertical + ' '.repeat(leftPadding) + chalk.bold(text) + ' '.repeat(rightPadding) + vertical;
+  
+  return [
+    chalk.bold.cyan(horizontalBorder),
+    chalk.cyan(emptyLine),
+    chalk.cyan(emptyLine),
+    chalk.cyan(textLine),
+    chalk.cyan(emptyLine),
+    chalk.cyan(emptyLine),
+    chalk.bold.cyan(bottomLeft + horizontal.repeat(totalWidth) + bottomRight)
+  ].join('\n');
 }

package/src/printer.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { createFormatter } from './formatters/factory.js';
-import { getTaskPrefix } from './task.js';
+import { getTaskPrefix, runningTasks } from './task.js';
 
 export class Printer {
   constructor(taskType, taskId = null) {
@@ -21,9 +21,21 @@ export class Printer {
       extra.duration = Date.now() - this.startTime;
     }
 
+    // Get task info to check for parent task
+    let displayTaskName = taskName;
+    if (this.taskId) {
+      const taskInfo = runningTasks.get(this.taskId);
+      if (taskInfo && taskInfo.parentId) {
+        const parentTask = runningTasks.get(taskInfo.parentId);
+        if (parentTask) {
+          displayTaskName = `${parentTask.name} > ${taskName}`;
+        }
+      }
+    }
+
     // Add task prefix for parallel tasks
     const prefix = this.taskId ? getTaskPrefix(this.taskId) : '';
-    const prefixedTaskName = prefix ? `${prefix} ${taskName}` : taskName;
+    const prefixedTaskName = prefix ? `${prefix} ${displayTaskName}` : displayTaskName;
 
     const output = this.formatter.format(prefixedTaskName, status, this.taskType, extra);
     if (output) {