bunosh 0.3.0 → 0.3.1

package/README.md

@@ -373,34 +373,74 @@ Commands:
 All Bunosh functions are available via `global.bunosh`:
 
 ```javascript
-const { exec, fetch, writeToFile, copyFile, say, ask, yell, task } = global.bunosh;
+const { exec, shell, fetch, writeToFile, copyFile, say, ask, yell, task } = global.bunosh;
 ```
 
-### Shell Execution (`exec`)
+### Shell Execution
 
-The `exec` function runs shell commands and returns a `TaskResult` object with the command output and status.
+Bunosh provides two ways to execute shell commands:
+
+#### `exec` - Universal Shell Execution
+
+Best for complex commands, cross-platform compatibility, and when you need real-time streaming output.
+
+```javascript
+// Complex shell commands with pipes and redirections
+await exec`find . -name "*.js" | grep -v node_modules | wc -l`;
+await exec`npm install --verbose`;  // Shows progress in real-time
+await exec`docker build . | tee build.log`;
+```
+
+#### `shell` - Native Bun Shell (with Node.js fallback)
+
+Best for simple commands when running under Bun for maximum performance.
 
 ```javascript
-// Simple commands
-await exec`echo "Hello World"`;
-await exec`npm install`;
+// Simple, fast commands
+await shell`pwd`;
+await shell`echo "Hello World"`;
+await shell`ls -la`;
+await shell`cat package.json`;
+```
+
+#### When to Use Which?
 
-// With environment variables
+**Use `shell` when:**
+- ✅ Running under Bun for optimal performance  
+- ✅ Executing simple commands (`pwd`, `ls`, `echo`, `cat`)
+- ✅ Want fastest possible execution
+- ✅ Working with basic file operations
+
+**Use `exec` when:**
+- ✅ Need cross-platform compatibility (Node.js + Bun)
+- ✅ Using complex shell features (pipes, redirections, command chaining)
+- ✅ Want real-time streaming output for long-running commands
+- ✅ Running package managers (`npm install`, `docker build`)
+
+Both support the same API and return the same `TaskResult` object:
+
+```javascript
+// Both tasks support environment variables  
+await shell`echo $NODE_ENV`.env({ NODE_ENV: 'production' });
 await exec`echo $NODE_ENV`.env({ NODE_ENV: 'production' });
 
-// With working directory
+// Both support working directory changes
+await shell`pwd`.cwd('/tmp');
 await exec`ls -la`.cwd('/tmp');
 
-// Complex shell commands
-await exec`find . -name "*.js" | grep -v node_modules | wc -l`;
+// Choose based on complexity and performance needs
+await shell`cat package.json`;              // Simple, fast
+await exec`npm install --verbose`;          // Complex, streaming
 ```
 
 #### TaskResult Object
 
-The `exec` function returns a `TaskResult` object with the following properties and methods:
+Both `exec` and `shell` return a `TaskResult` object with the following properties and methods:
 
 ```javascript
 const result = await exec`ls -la`;
+// or 
+const result = await shell`ls -la`;
 
 // Properties
 result.status   // 'success' or 'fail' 
@@ -474,15 +514,203 @@ copyFile('template.js', 'output.js');
 ```
 
 ### User Interaction
+
+#### `ask()` - Interactive User Input
+
+The `ask()` function provides flexible ways to get user input with smart parameter detection and multiple modes:
+
 ```javascript
-// Get user input
+// === SIMPLE SYNTAX WITH SMART DETECTION ===
+
+// Basic text input
 const name = await ask('What is your name?');
 
+// Text input with default value
+const projectName = await ask('Project name:', 'my-awesome-app');
+
+// Boolean confirmation (auto-detects confirm type)
+const shouldContinue = await ask('Continue with deployment?', true);
+const forceUpdate = await ask('Force update?', false);
+
+// Number input with default
+const port = await ask('Enter port number:', 3000);
+
+// Single choice selection (auto-detects from array)
+const framework = await ask('Choose your framework:', [
+  'React', 'Vue', 'Angular', 'Svelte'
+]);
+
+// Multiple choice selection (array + options)
+const features = await ask('Select features to include:', [
+  'TypeScript', 'ESLint', 'Prettier', 'Tests', 'CI/CD'
+], { multiple: true });
+
+// === ADVANCED OPTIONS SYNTAX ===
+
+// Multiline text input (opens system editor)
+const description = await ask('Enter project description:', {
+  multiline: true  // Same as editor: true
+});
+
+// Editor input with default content
+const config = await ask('Edit configuration:', {
+  editor: true,
+  default: 'Initial content here...'
+});
+
+// Password input (hidden)
+const password = await ask('Enter password:', {
+  type: 'password'
+});
+
+// Mixed: default value + additional options
+const email = await ask('Email address:', 'user@example.com', {
+  validate: (input) => input.includes('@') || 'Please enter valid email'
+});
+```
+
+#### Ask Function Signatures
+
+```javascript
+// Smart detection syntax
+ask(question, defaultValue, options?)
+ask(question, choices[], options?)  
+ask(question, options)
+
+// Examples:
+ask('Name?', 'John')                    // String default
+ask('Continue?', true)                  // Boolean -> confirm type
+ask('Port?', 3000)                      // Number default  
+ask('Color?', ['red', 'blue'])          // Array -> choices
+ask('Colors?', ['red', 'blue'], { multiple: true })  // Array + options
+```
+
+#### Ask Options Reference
+
+| Parameter/Option | Type | Description | Example |
+|------------------|------|-------------|---------|
+| **Smart Detection** | | |
+| `defaultValue` | String/Number | Sets default value for text/number input | `'John'`, `3000` |
+| `defaultValue` | Boolean | Auto-detects as confirmation prompt | `true`, `false` |
+| `choices` | Array | Auto-detects as selection list | `['A', 'B', 'C']` |
+| **Options Object** | | |
+| `multiple` | Boolean | Enables multiple selections (requires `choices`) | `true` |
+| `multiline` | Boolean | Opens system editor for multi-line input | `true` |
+| `editor` | Boolean | Opens system editor for multi-line input (same as `multiline`) | `true` |
+| `default` | Any | Default value or content (when using options object) | `'default value'` |
+| `type` | String | Input type: `'input'`, `'confirm'`, `'password'`, `'number'` | `'password'` |
+| `validate` | Function | Custom validation function | `(input) => input.length > 0` |
+
+#### Advanced Ask Examples
+
+```javascript
+/**
+ * Interactive project setup with smart syntax
+ */
+export async function setupProject() {
+  // Simple syntax with smart detection
+  const projectName = await ask('Project name:', 'my-awesome-project');
+  
+  const projectType = await ask('Project type:', [
+    'Web App', 'API', 'CLI Tool', 'Library'
+  ]);
+  
+  const dependencies = await ask('Select dependencies:', [
+    'express', 'lodash', 'axios', 'moment', 'uuid'
+  ], { multiple: true });
+  
+  const useTypescript = await ask('Use TypeScript?', false);
+  
+  // Editor input for complex configuration
+  const packageJson = await ask('Customize package.json:', {
+    editor: true,
+    default: JSON.stringify({
+      name: projectName,
+      version: '1.0.0',
+      description: '',
+      dependencies: {}
+    }, null, 2)
+  });
+  
+  say(`Creating ${projectType}: ${projectName}`);
+  say(`Dependencies: ${dependencies.join(', ')}`);
+  say(`TypeScript: ${useTypescript ? 'Yes' : 'No'}`);
+  
+  writeToFile('package.json', packageJson);
+}
+
+/**
+ * Git commit with editor input
+ */
+export async function interactiveCommit() {
+  const message = await ask('Enter commit message:', {
+    editor: true,
+    default: 'feat: \n\n# Write your commit message above\n# First line: brief summary (50 chars max)\n# Blank line, then detailed explanation'
+  });
+  
+  await exec`git commit -m "${message}"`;
+  say('✅ Committed successfully!');
+}
+
+/**
+ * Database migration with smart syntax
+ */
+export async function migrate() {
+  // Smart array detection for choices
+  const action = await ask('Migration action:', [
+    'Run pending migrations', 
+    'Rollback last migration', 
+    'Reset database', 
+    'Create new migration'
+  ]);
+  
+  if (action === 'Reset database') {
+    // Smart boolean detection for confirmation
+    const confirmed = await ask('⚠️  This will DELETE ALL DATA. Are you sure?', false);
+    
+    if (!confirmed) {
+      say('Migration cancelled');
+      return;
+    }
+  }
+  
+  // Execute migration based on selection...
+}
+
+/**
+ * Server configuration with mixed smart syntax
+ */
+export async function configureServer() {
+  // Simple defaults
+  const serverName = await ask('Server name:', 'my-server');
+  const port = await ask('Port number:', 8080);
+  const enableHTTPS = await ask('Enable HTTPS?', true);
+  
+  // Array with additional options
+  const databases = await ask('Select databases to connect:', [
+    'PostgreSQL', 'MongoDB', 'Redis', 'MySQL'
+  ], { multiple: true });
+  
+  // Mix of default + validation
+  const adminEmail = await ask('Admin email:', 'admin@example.com', {
+    validate: (email) => email.includes('@') || 'Please enter a valid email'
+  });
+  
+  say(`Configuring ${serverName} on port ${port}`);
+  say(`HTTPS: ${enableHTTPS ? 'Enabled' : 'Disabled'}`);
+  say(`Databases: ${databases.join(', ')}`);
+  say(`Admin: ${adminEmail}`);
+}
+```
+
+#### Output Functions
+
+```javascript
 // Output messages
-say('Building project...');          // Normal output
-yell('BUILD COMPLETE!');             // Emphasized output
+say('Building project...');          // Normal output with !
+yell('BUILD COMPLETE!');             // Emphasized ASCII art output
 
-// Wrap long operations
+// Wrap long operations with progress
 await task('Installing dependencies', async () => {
   await exec`npm install`;
 });

package/index.js

@@ -1,4 +1,5 @@
 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";
@@ -6,19 +7,21 @@ 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 };
-
+export { exec, shell, fetch, writeToFile, copyFile, ai, ask, yell, say, task, stopOnFail, ignoreFail };
 
 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,
@@ -27,6 +30,6 @@ global.bunosh = {
   task,
   buildCmd,
   $: exec,
-}
+};
 
 export default global.bunosh;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "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/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/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/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;
+}