bunosh 0.4.1 → 0.4.7

package/bunosh.js

@@ -4,6 +4,7 @@
 globalThis._bunoshStartTime = Date.now();
 globalThis._bunoshCommandCompleted = false;
 globalThis._bunoshGlobalTasksExecuted = [];
+globalThis._bunoshIgnoreFailuresMode = false;
 globalThis._bunoshGlobalTaskStatus = {
   RUNNING: 'running',
   FAIL: 'fail',
@@ -13,98 +14,248 @@ globalThis._bunoshGlobalTaskStatus = {
 
 // Now import modules
 
-import program, { BUNOSHFILE, banner }  from "./src/program.js";
+import bunosh, { BUNOSHFILE, banner }  from "./src/program.js";
 import { existsSync, readFileSync, statSync } from "fs";
 import init from "./src/init.js";
 import path from "path";
+import { config } from "dotenv";
 
+/**
+ * Load environment variables from .env files following Bun's loading order
+ * @param {string} bunoshfileDir - Directory containing the Bunoshfile
+ * @param {string} customEnvFile - Optional custom env file path from --env-file option
+ */
+function loadEnvFiles(bunoshfileDir, customEnvFile = null) {
+  if (customEnvFile) {
+    // Load the specified env file
+    const customEnvPath = path.isAbsolute(customEnvFile)
+      ? customEnvFile
+      : path.resolve(bunoshfileDir, customEnvFile);
+
+    if (existsSync(customEnvPath)) {
+      config({ path: customEnvPath });
+    } else {
+      console.warn(`Warning: Specified env file not found: ${customEnvPath}`);
+    }
+    return;
+  }
+
+  // Follow Bun's automatic loading order
+  const envFiles = [
+    '.env',
+    '.env.production',
+    '.env.development',
+    '.env.test',
+    '.env.local'
+  ];
+
+  envFiles.forEach(envFile => {
+    const envPath = path.join(bunoshfileDir, envFile);
+    if (existsSync(envPath)) {
+      config({ path: envPath });
+    }
+  });
+}
+
+async function loadBunoshfiles(tasksFile) {
+  const path = await import('path');
+  const fs = await import('fs');
+  
+  // Get the directory and base name of the tasks file
+  const dir = path.dirname(tasksFile);
+  const baseName = path.basename(tasksFile, '.js');
+  
+  // Find all matching Bunoshfile variants
+  const files = fs.readdirSync(dir);
+  const bunoshFiles = files
+    .filter(file => {
+      // Match Bunoshfile.js, Bunoshfile.*.js
+      const regex = new RegExp(`^${baseName}(\\.\\w+)?\\.js$`);
+      return regex.test(file);
+    })
+    .sort(); // Ensure consistent order
+  
+  const allTasks = {};
+  const allSources = {};
+  
+  for (const file of bunoshFiles) {
+    const filePath = path.join(dir, file);
+    try {
+      // Extract namespace from filename
+      let namespace = '';
+      if (file !== `${baseName}.js`) {
+        // Remove baseName and .js, then remove the leading dot
+        namespace = file.slice(baseName.length, -3).substring(1);
+      }
+      
+      const tasks = await import(filePath);
+      const source = fs.readFileSync(filePath, 'utf-8');
+      
+      // Add namespace prefix to tasks if namespace exists
+      if (namespace) {
+        Object.keys(tasks).forEach(key => {
+          if (typeof tasks[key] === 'function') {
+            allTasks[`${namespace}:${key}`] = tasks[key];
+            allSources[`${namespace}:${key}`] = { source, namespace, originalFnName: key };
+          }
+        });
+      } else {
+        // No namespace for the main Bunoshfile
+        Object.keys(tasks).forEach(key => {
+          if (typeof tasks[key] === 'function') {
+            allTasks[key] = tasks[key];
+            allSources[key] = { source, namespace: '', originalFnName: key };
+          }
+        });
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not load ${file}:`, error.message);
+    }
+  }
+  
+  return { tasks: allTasks, sources: allSources };
+}
 
 async function main() {
 
-  // Parse --bunoshfile flag before importing tasks
+  // Parse --bunoshfile flag or BUNOSHFILE env var 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);
+  } else if (process.env.BUNOSHFILE) {
+    customBunoshfile = process.env.BUNOSHFILE;
+  }
+
+  // Parse --env-file flag
+  const envFileIndex = process.argv.findIndex(arg => arg.startsWith('--env-file='));
+  let customEnvFile = null;
+
+  if (envFileIndex !== -1) {
+    customEnvFile = process.argv[envFileIndex].split('=')[1];
+    // Remove the flag from process.argv so it doesn't interfere with command parsing
+    process.argv.splice(envFileIndex, 1);
+  }
+
+  // Check for -mcp flag first
+  const mcpFlagIndex = process.argv.indexOf('-mcp');
+  if (mcpFlagIndex !== -1) {
+    // Remove the flag from process.argv
+    process.argv.splice(mcpFlagIndex, 1);
+
+    // Set environment variable to indicate MCP mode
+    process.env.BUNOSH_MCP_MODE = 'true';
+
+    // Import MCP server and start it
+    const { createMcpServer, startMcpServer } = await import('./src/mcp-server.js');
+
+    let tasksFile;
+    let bunoshfileDir;
+    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);
+        bunoshfileDir = resolvedPath;
+      } else {
+        tasksFile = resolvedPath;
+        bunoshfileDir = path.dirname(resolvedPath);
+      }
+    } else {
+      tasksFile = path.join(process.cwd(), BUNOSHFILE);
+      bunoshfileDir = process.cwd();
+    }
+
+    if (!existsSync(tasksFile)) {
+      console.error('Bunoshfile not found for MCP mode');
+      process.exit(1);
+    }
+
+    // Load environment files from the Bunoshfile directory
+    loadEnvFiles(bunoshfileDir, customEnvFile);
+
+    // Load tasks and sources
+    const { tasks, sources } = await loadBunoshfiles(tasksFile);
+
+    // Create and start MCP server
+    const server = createMcpServer(tasks, sources);
+    await startMcpServer(server);
+
+    return; // Exit early for MCP mode
   }
 
   let tasksFile;
+  let bunoshfileDir;
   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);
+      bunoshfileDir = resolvedPath;
       // Change working directory to the bunoshfile directory
       process.chdir(resolvedPath);
     } else {
       tasksFile = resolvedPath;
+      bunoshfileDir = path.dirname(resolvedPath);
       // Change working directory to the bunoshfile's directory
       process.chdir(path.dirname(resolvedPath));
     }
   } else {
     tasksFile = path.join(process.cwd(), BUNOSHFILE);
+    bunoshfileDir = process.cwd();
   }
 
+  // Load environment files from the Bunoshfile directory
+  loadEnvFiles(bunoshfileDir, customEnvFile);
+
   // 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);
+    (async () => {
+      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();
       }
-      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 {
+      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
+        for (const [key, value] of Object.entries(global.bunosh)) {
+          if (typeof value === 'function') {
             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();
+        process.exit(0);
+      } catch (error) {
+        console.error('Error executing JavaScript:', error.message);
+        process.exit(1);
       }
-      
-      // 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);
-    }
+    })();
+    return;
   }
 
   if (!existsSync(tasksFile)) {
@@ -124,19 +275,11 @@ async function main() {
     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);
-  });
+
+// Load all Bunoshfile variants
+const { tasks, sources } = await loadBunoshfiles(tasksFile);
+await bunosh(tasks, sources);
 }
 
 main().catch((error) => {
@@ -162,45 +305,66 @@ process.on('uncaughtException', (error) => {
   
   console.error('\n❌ Uncaught Exception:');
   console.error(error.message);
-  if (error.stack && process.env.BUNOSH_DEBUG) {
+  if (error.stack) {
     console.error(error.stack);
   }
   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 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:'));
-  
-  // Set exit code to 1 if any tasks failed AND we're not in test environment
-  if (tasksFailed > 0 && !isTestEnvironment) {
+                            (typeof Bun !== 'undefined' && typeof Bun?.jest !== 'undefined') ||
+                            commandArgs.some(arg => {
+                              const lowerArg = arg.toLowerCase();
+                              return lowerArg.includes('vitest') ||
+                                     lowerArg.includes('jest') ||
+                                     lowerArg === '--test' ||
+                                     lowerArg.startsWith('test:');
+                            });
+
+  const ignoreFailuresMode = globalThis._bunoshIgnoreFailuresMode || false;
+
+  if (process.env.BUNOSH_DEBUG) {
+    console.log('\n[DEBUG] Exit handler:');
+    console.log('  tasksFailed:', tasksFailed);
+    console.log('  isTestEnvironment:', isTestEnvironment);
+    console.log('  ignoreFailuresMode:', ignoreFailuresMode);
+    console.log('  NODE_ENV:', process.env.NODE_ENV);
+    console.log('  commandArgs:', commandArgs);
+    console.log('  full process.argv:', process.argv);
+    if (isTestEnvironment) {
+      const matchingArg = commandArgs.find(arg => {
+        const lowerArg = arg.toLowerCase();
+        return lowerArg.includes('vitest') ||
+               lowerArg.includes('jest') ||
+               lowerArg === '--test' ||
+               lowerArg.startsWith('test:');
+      });
+      console.log('  Matched command arg:', matchingArg);
+    }
+  }
+
+  if (tasksFailed > 0 && !isTestEnvironment && !ignoreFailuresMode) {
     process.exitCode = 1;
   }
-  
-  const finalExitCode = (tasksFailed > 0 && !isTestEnvironment) ? 1 : code;
+
+  const finalExitCode = (tasksFailed > 0 && !isTestEnvironment && !ignoreFailuresMode) ? 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.4.1",
+  "version": "0.4.7",
   "type": "module",
   "module": "index.js",
   "bin": {
@@ -19,10 +19,12 @@
     "@ai-sdk/openai": "^2.0.23",
     "@babel/parser": "^7.27.5",
     "@babel/traverse": "^7.27.4",
+    "@modelcontextprotocol/sdk": "^1.19.1",
     "ai": "^5.0.29",
     "chalk": "^5.4.1",
     "commander": "^14.0.0",
     "debug": "^4.4.1",
+    "dotenv": "^17.2.3",
     "fs-extra": "^11.3.0",
     "inquirer": "^12.6.3",
     "timer-node": "^5.0.9",
@@ -46,11 +48,11 @@
     "test:watch": "bun test test/ --watch",
     "test:e2e": "vitest run",
     "test:e2e:watch": "vitest",
-    "build": "bun build ./bunosh.js --compile --outfile bunosh",
+    "build": "bun build ./bunosh.js --compile --define BUNOSH_EXECUTABLE=true --outfile bunosh",
     "build:all": "npm run build:linux && npm run build:macos && npm run build:windows",
-    "build:linux": "bun build ./bunosh.js --compile --target=bun-linux-x64 --outfile dist/bunosh-linux-x64",
-    "build:macos": "bun build ./bunosh.js --compile --target=bun-darwin-arm64 --outfile dist/bunosh-darwin-arm64",
-    "build:windows": "bun build ./bunosh.js --compile --target=bun-windows-x64 --outfile dist/bunosh-windows-x64.exe",
+    "build:linux": "bun build ./bunosh.js --compile --define BUNOSH_EXECUTABLE=true --target=bun-linux-x64 --outfile dist/bunosh-linux-x64",
+    "build:macos": "bun build ./bunosh.js --compile --define BUNOSH_EXECUTABLE=true --target=bun-darwin-arm64 --outfile dist/bunosh-darwin-arm64",
+    "build:windows": "bun build ./bunosh.js --compile --define BUNOSH_EXECUTABLE=true --target=bun-windows-x64 --outfile dist/bunosh-windows-x64.exe",
     "test:build": "npm run build && ./bunosh --help && rm bunosh",
     "hello:other": "bunosh hello:other",
     "hello:world": "bunosh hello:world",

package/src/completion.js

@@ -188,11 +188,24 @@ export function getCompletionCommands() {
  * Converts function name to command name (same logic as program.js)
  */
 function prepareCommandName(name) {
-  name = name
+  // name is already the final command name (could be namespaced or not)
+  // For namespaced commands, only transform the function part (after the last colon)
+  const lastColonIndex = name.lastIndexOf(':');
+  if (lastColonIndex !== -1) {
+    const namespace = name.substring(0, lastColonIndex);
+    const commandPart = name.substring(lastColonIndex + 1);
+    return `${namespace}:${toKebabCase(commandPart)}`;
+  }
+  
+  // For non-namespaced commands, just convert to kebab-case
+  return toKebabCase(name);
+}
+
+function toKebabCase(name) {
+  return name
     .split(/(?=[A-Z])/)
     .join("-")
     .toLowerCase();
-  return name.replace("-", ":");
 }
 
 /**

package/src/formatters/console.js

@@ -3,7 +3,7 @@ import { BaseFormatter } from './base.js';
 
 const STATUS_CONFIG = {
   start: { icon: '▶', color: 'blue' },
-  finish: { icon: '✓', color: 'green' },
+  finish: { icon: '✔', color: 'green' },
   error: { icon: '✗', color: 'red' },
   warning: { icon: '⚠', color: 'yellow' },
   output: { icon: ' ', color: 'white' },
@@ -11,6 +11,9 @@ const STATUS_CONFIG = {
 };
 
 export class ConsoleFormatter extends BaseFormatter {
+  shouldDelayStart() {
+    return false;
+  }
   format(taskName, status, taskType, extra = {}) {
     const config = STATUS_CONFIG[status];
     if (!config) {
@@ -20,7 +23,7 @@ export class ConsoleFormatter extends BaseFormatter {
     const icon = chalk[config.color](config.icon);
     const taskTypeFormatted = taskType ? chalk.bold(taskType) + ' ' : '';
     const taskNameFormatted = chalk.yellow(taskName);
-    
+
     const extraParts = [];
     Object.entries(extra).forEach(([key, value]) => {
       if (value !== null && value !== undefined) {
@@ -41,7 +44,7 @@ export class ConsoleFormatter extends BaseFormatter {
     const terminalWidth = process.stdout.columns || 100;
     let leftContent = `${icon} ${taskTypeFormatted}${taskNameFormatted}`;
     let rightContent = '';
-    
+
     if (extraParts.length > 0) {
       rightContent = `(${extraParts.join(', ')})`;
     }
@@ -53,7 +56,9 @@ export class ConsoleFormatter extends BaseFormatter {
     let line = leftContent + padding + rightContent;
 
     if (icon.trim()) {
-      line = chalk.bgGray(line);
+      // Apply underline to the task name/type only, not the status in parentheses
+      const underlineContent = taskTypeFormatted + taskNameFormatted + padding;
+      line = icon + ' ' + chalk.underline(underlineContent) + rightContent;
     }
 
     let result = line;
@@ -79,4 +84,4 @@ export class ConsoleFormatter extends BaseFormatter {
   static detect() {
     return !process.env.CI;
   }
-}
+}

package/src/formatters/factory.js

@@ -6,7 +6,28 @@ const FORMATTERS = [
   ConsoleFormatter
 ];
 
+// Global test formatter override
+let testFormatterOverride = null;
+
 export function createFormatter() {
+  // Use test override if set
+  if (testFormatterOverride) {
+    return new testFormatterOverride();
+  }
+  
+  // Check for explicit formatter override via environment variable
+  if (process.env.BUNOSH_FORMATTER) {
+    const requested = process.env.BUNOSH_FORMATTER.toLowerCase();
+    switch (requested) {
+      case 'console':
+        return new ConsoleFormatter();
+      case 'github-actions':
+        return new GitHubActionsFormatter();
+      default:
+        console.warn(`Unknown BUNOSH_FORMATTER: ${requested}. Using auto-detection.`);
+    }
+  }
+  
   for (const FormatterClass of FORMATTERS) {
     if (FormatterClass.detect && FormatterClass.detect()) {
       return new FormatterClass();
@@ -14,4 +35,13 @@ export function createFormatter() {
   }
   
   return new ConsoleFormatter();
+}
+
+// Test utilities
+export function setTestFormatter(FormatterClass) {
+  testFormatterOverride = FormatterClass;
+}
+
+export function clearTestFormatter() {
+  testFormatterOverride = null;
 }

package/src/io.js

@@ -7,6 +7,11 @@ export function say(...args) {
 }
 
 export async function ask(question, defaultValueOrOptions = {}, options = {}) {
+  // Check if we're in MCP mode and should use the interactive ask function
+  if (globalThis._mcpAskFunction) {
+    return globalThis._mcpAskFunction(question, defaultValueOrOptions, options);
+  }
+
   // Track that we're in an ask operation to prevent duplicate exit summaries
   globalThis._bunoshInAskOperation = true;
   // Smart parameter detection