bunosh 0.2.3 → 0.3.1

package/bunosh.js

@@ -3,6 +3,7 @@ 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
@@ -49,8 +50,93 @@ if (!existsSync(tasksFile)) {
 }
 
 import(tasksFile).then((tasks) => {
-  program(tasks, readFileSync(tasksFile, "utf-8"));
-}).catch((e) => {
-  console.error(`Error loading: ${tasksFile}`);
-  console.error(e);
+  try {
+    const source = readFileSync(tasksFile, "utf-8");
+    program(tasks, source);
+  } catch (error) {
+    handleBunoshfileError(error, tasksFile);
+  }
+}).catch((error) => {
+  handleBunoshfileError(error, tasksFile);
 });
+
+function handleBunoshfileError(error, filePath) {
+  banner();
+  console.log();
+  
+  // Check for Babel parser syntax errors
+  if (error.code === 'BABEL_PARSER_SYNTAX_ERROR' || 
+      (error.reasonCode && error.loc) || 
+      error.constructor.name === 'SyntaxError') {
+    
+    console.error(`❌ Syntax Error in ${path.basename(filePath)}:`);
+    console.log();
+    
+    if (error.loc) {
+      console.error(`   Line ${error.loc.line}, Column ${error.loc.column}:`);
+      
+      // Provide specific error messages based on reasonCode
+      if (error.reasonCode === 'VarRedeclaration') {
+        console.error(`   Variable redeclaration - '${error.message}' is already declared`);
+      } else if (error.reasonCode && error.reasonCode.includes('Unexpected')) {
+        console.error(`   ${error.reasonCode}: ${error.message || 'Unexpected token'}`);
+      } else {
+        console.error(`   ${error.message || error.reasonCode || 'Invalid syntax'}`);
+      }
+    } else {
+      console.error(`   ${error.message || 'Invalid JavaScript syntax'}`);
+    }
+    
+    console.log();
+    console.log('💡 Common issues:');
+    console.log('   • Missing semicolons or commas');
+    console.log('   • Unclosed brackets, parentheses, or quotes'); 
+    console.log('   • Invalid variable declarations');
+    console.log('   • Mixing import/export with require/module.exports');
+    console.log();
+    console.log(`📝 Edit your Bunoshfile: ${color.blue('bunosh edit')}`);
+    console.log(`🔧 Validate syntax: ${color.blue(`bun --check ${path.basename(filePath)}`)}`);
+    
+  } else if (error.message && error.message.includes('SyntaxError')) {
+    console.error(`❌ JavaScript Syntax Error in ${path.basename(filePath)}:`);
+    console.log();
+    console.error(`   ${error.message}`);
+    console.log();
+    console.log(`💡 Try running: ${color.blue('bun --check Bunoshfile.js')}`);
+    console.log(`📝 Edit your Bunoshfile: ${color.blue('bunosh edit')}`);
+    
+  } else if (error.code === 'MODULE_NOT_FOUND' || 
+             error.message?.includes('Cannot resolve') ||
+             error.message?.includes('Could not resolve')) {
+    console.error(`❌ Module Import Error in ${path.basename(filePath)}:`);
+    console.log();
+    console.error(`   ${error.message}`);
+    console.log();
+    console.log('💡 Common solutions:');
+    console.log(`   • Run: ${color.blue('bun install')}`);
+    console.log('   • Check import paths are correct');
+    console.log('   • Ensure dependencies are listed in package.json');
+    
+  } else {
+    console.error(`❌ Error loading ${path.basename(filePath)}:`);
+    console.log();
+    console.error(`   ${error.message || error.toString()}`);
+    
+    // Add stack trace for debugging if available
+    if (process.env.BUNOSH_DEBUG) {
+      console.log();
+      console.log('🐛 Debug stack trace:');
+      console.log(error.stack || 'No stack trace available');
+    }
+    
+    console.log();
+    console.log('💡 Try:');
+    console.log(`   • Check the file exists: ${color.blue(`ls -la ${path.basename(filePath)}`)}`);
+    console.log(`   • Validate syntax: ${color.blue(`bun --check ${path.basename(filePath)}`)}`);
+    console.log(`   • Edit the file: ${color.blue('bunosh edit')}`);
+    console.log(`   • Run with debug: ${color.blue('BUNOSH_DEBUG=1 bunosh')}`);
+  }
+  
+  console.log();
+  process.exit(1);
+}

package/index.js

@@ -1,30 +1,35 @@
 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, 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,
   stopOnFail,
   ignoreFail,
   task,
   buildCmd,
   $: exec,
-}
+};
 
 export default global.bunosh;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "type": "module",
   "module": "index.js",
   "bin": {
@@ -14,15 +14,19 @@
   },
   "types": "types.d.ts",
   "dependencies": {
+    "@ai-sdk/anthropic": "^2.0.9",
+    "@ai-sdk/groq": "^2.0.16",
+    "@ai-sdk/openai": "^2.0.23",
     "@babel/parser": "^7.27.5",
     "@babel/traverse": "^7.27.4",
+    "ai": "^5.0.29",
     "chalk": "^5.4.1",
     "commander": "^14.0.0",
     "debug": "^4.4.1",
     "fs-extra": "^11.3.0",
     "inquirer": "^12.6.3",
-    "open-editor": "^5.1.0",
-    "timer-node": "^5.0.9"
+    "timer-node": "^5.0.9",
+    "zod": "^4.1.5"
   },
   "license": "ISC",
   "files": [

package/src/init.js

@@ -3,8 +3,10 @@ import color from "chalk";
 import fs from 'fs';
 
 const template = `
-// tasks
-const { exec, fetch, writeToFile, task } = global.bunosh;
+// Bunosh CLI required to execute tasks from this file
+// Get it here -> https://github.com/DavertMik/bunosh/releases
+
+const { exec, fetch, writeToFile, task, ai } = global.bunosh;
 
 // input/output
 const { say, ask, yell } = global.bunosh;
@@ -22,13 +24,19 @@ export async function helloWorld() {
   // use fetch() to make HTTP requests
   // await fetch('https://reqres.in/api/users')
 
+  // use ai() to make AI requests with structured output:
+  // REQUIRED env vars: AI_MODEL and any of: OPENAI_API_KEY, ANTHROPIC_API_KEY, or GROQ_API_KEY
+  // await ai('Summarize this text: JavaScript is awesome', {
+  //   summary: 'Brief summary of the text',
+  //   sentiment: 'Sentiment of the text (positive/negative/neutral)',
+  //   keyWords: 'Main keywords from the text'
+  // });
+
   // add arguments and options to this function if needed
   // export async function helloWorld(userName, opts = { force: false })
   //
   // bunosh hello:world 'bob' --force
 
-  // use ignoreFail(true) to prevent the command from stopping on error
-
   yell('Heloo Bunosh!');
   say('Edit me with bunosh edit');
 }

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';
@@ -37,7 +37,10 @@ export default function bunosh(commands, source) {
     showGlobalOptions: false,
     visibleGlobalOptions: _opt => [],
     visibleOptions: _opt => [],
-    visibleCommands: cmd => cmd.commands.filter(c => !internalCommands.includes(c)),
+    visibleCommands: cmd => {
+      const commands = cmd.commands.filter(c => !internalCommands.includes(c));
+      return commands.filter(c => !c.name().startsWith('npm:'));
+    },
     subcommandTerm: (cmd) => color.white.bold(cmd.name()),
     subcommandDescription: (cmd) => color.gray(cmd.description()),
   });
@@ -46,13 +49,20 @@ export default function bunosh(commands, source) {
   program.showSuggestionAfterError(true);
   program.addHelpCommand(false);
 
-  const completeAst = babelParser.parse(source, {
-    sourceType: "module",
-    ranges: true,
-    tokens: true,
-    comments: true,
-    attachComment: true,
-  });
+  let completeAst;
+  try {
+    completeAst = babelParser.parse(source, {
+      sourceType: "module",
+      ranges: true,
+      tokens: true,
+      comments: true,
+      attachComment: true,
+    });
+  } catch (parseError) {
+    // Re-throw with more specific error information
+    parseError.code = 'BABEL_PARSER_SYNTAX_ERROR';
+    throw parseError;
+  }
 
   const comments = fetchComments();
 
@@ -241,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);
@@ -282,11 +296,11 @@ export default function bunosh(commands, source) {
       try {
         // Detect current shell or use specified shell
         const shell = options.shell || detectCurrentShell();
-        
+
         if (!shell) {
           console.error('❌ Could not detect your shell. Please specify one:');
           console.log('   bunosh setup-completion --shell bash');
-          console.log('   bunosh setup-completion --shell zsh'); 
+          console.log('   bunosh setup-completion --shell zsh');
           console.log('   bunosh setup-completion --shell fish');
           process.exit(1);
         }
@@ -296,7 +310,7 @@ export default function bunosh(commands, source) {
 
         // Get paths for this shell
         const paths = getCompletionPaths(shell);
-        
+
         // Check if already installed
         if (!options.force && fs.existsSync(paths.completionFile)) {
           console.log(`⚠️  Completion already installed at: ${paths.completionFile}`);
@@ -311,7 +325,7 @@ export default function bunosh(commands, source) {
 
         // Report success
         console.log(`✅ Completion installed: ${color.green(paths.completionFile)}`);
-        
+
         if (result.configFile && result.added) {
           console.log(`📝 Updated shell config: ${color.green(result.configFile)}`);
           console.log();
@@ -327,10 +341,10 @@ export default function bunosh(commands, source) {
           console.log(`ℹ️  Shell config already has completion setup: ${result.configFile}`);
           console.log('   Restart your terminal if completion isn\'t working.');
         }
-        
+
         console.log();
         console.log('🎯 Test completion by typing: ' + color.bold('bunosh <TAB>'));
-        
+
       } catch (error) {
         console.error(`❌ Setup failed: ${error.message}`);
         process.exit(1);
@@ -360,9 +374,9 @@ export default function bunosh(commands, source) {
             const { getLatestRelease, isNewerVersion } = await import('./upgrade.js');
             const release = await getLatestRelease();
             const latestVersion = release.tag_name;
-            
+
             console.log(`📦 Latest version: ${color.bold(latestVersion)}`);
-            
+
             if (isNewerVersion(latestVersion, currentVersion)) {
               console.log(`✨ ${color.green('Update available!')} ${currentVersion} → ${latestVersion}`);
               console.log('Run ' + color.bold('bunosh upgrade') + ' to update.');
@@ -405,7 +419,7 @@ export default function bunosh(commands, source) {
 
       } catch (error) {
         console.error(`❌ Upgrade failed: ${error.message}`);
-        
+
         if (error.message.includes('Unsupported platform')) {
           console.log();
           console.log('💡 Supported platforms:');
@@ -416,21 +430,36 @@ export default function bunosh(commands, source) {
           console.log();
           console.log('💡 Try again later or check your internet connection.');
         }
-        
+
         process.exit(1);
       }
     });
 
   internalCommands.push(upgradeCmd);
 
+  // Add npm scripts help section if npm scripts exist
+  const npmScriptNamesForHelp = Object.keys(npmScripts);
+  if (npmScriptNamesForHelp.length > 0) {
+    const npmCommandsList = npmScriptNamesForHelp.sort().map(scriptName => {
+      const commandName = `npm:${scriptName}`;
+      const scriptCommand = npmScripts[scriptName];
+      return `  ${color.white.bold(commandName.padEnd(18))} ${color.gray(scriptCommand)}`;
+    }).join('\n');
+
+    program.addHelpText('after', `
+
+NPM Scripts:
+${npmCommandsList}
+`);
+  }
+
   program.addHelpText('after', `
 
 Special Commands:
+
   📝 Edit bunosh file: ${color.bold('bunosh edit')}
-  📥 Export scripts to package.json: ${color.bold('bunosh export:scripts')}
-  🔤 Generate shell completion: ${color.bold('bunosh completion bash|zsh|fish')}
-  ⚡ Auto-setup completion: ${color.bold('bunosh setup-completion')}
-  ⬆️  Upgrade bunosh: ${color.bold('bunosh upgrade')}
+  📥 Export commands as scripts to package.json: ${color.bold('bunosh export:scripts')}
+  🦾 Upgrade bunosh: ${color.bold('bunosh upgrade')}
 `);
 
   program.on("command:*", (cmd) => {

package/src/task.js

@@ -138,6 +138,14 @@ export class TaskResult {
     this.output = output;
   }
 
+  get hasFailed() {
+    return this.status === TaskStatus.FAIL;
+  }
+
+  get hasSucceeded() {
+    return this.status === TaskStatus.SUCCESS;
+  }
+
   static fail(output = null) {
     return new TaskResult({ status: TaskStatus.FAIL, output });
   }