bunosh 0.3.1 → 0.4.0

package/src/program.js

@@ -3,8 +3,7 @@ import babelParser from "@babel/parser";
 import traverseDefault from "@babel/traverse";
 const traverse = traverseDefault.default || traverseDefault;
 import color from "chalk";
-import fs from 'fs';
-import openEditor from './open-editor.js';
+import { readFileSync, existsSync, writeFileSync } from 'fs';
 import { yell } from './io.js';
 import cprint from "./font.js";
 import { handleCompletion, detectCurrentShell, installCompletion, getCompletionPaths } from './completion.js';
@@ -13,12 +12,47 @@ import { upgradeExecutable, isExecutable, getCurrentVersion } from './upgrade.js
 export const BUNOSHFILE = `Bunoshfile.js`;
 
 export const banner = () => {
-  console.log(cprint('Bunosh', { symbol: '⯀' }));
+  const asciiArt = cprint('Bunosh', { symbol: '⯀' });
+  console.log(createGradientAscii(asciiArt));
   console.log(color.gray('🍲 Your exceptional task runner'));
+  
+  // Try to get version from package.json
+  try {
+    // First try relative to src directory
+    const pkgPath = new URL('../package.json', import.meta.url);
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    console.log(`Version: ${color.bold(pkg.version)}`);
+  } catch (e) {
+    // Ignore if version can't be read
+  }
   console.log();
 };
 
-export default function bunosh(commands, source) {
+function createGradientAscii(asciiArt) {
+  const lines = asciiArt.split('\n');
+  const colors = [
+    color.bold.yellow,
+    color.bold.green,
+    color.bold.greenBright,
+    color.bold.cyan,
+    color.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');
+}
+
+export default async function bunosh(commands, source) {
   const program = new Command();
   program.option('--bunoshfile <path>', 'Path to the Bunoshfile');
 
@@ -27,19 +61,33 @@ export default function bunosh(commands, source) {
   // Load npm scripts from package.json
   const npmScripts = loadNpmScripts();
 
+  // Load personal commands from $HOME/Bunoshfile.js
+  const { tasks: homeTasks, source: homeSource } = await loadHomeTasks();
+
   program.configureHelp({
     commandDescription: _cmd => {
       // Show banner and description
       banner();
+      
+      // Try to get version from current directory's package.json for help display
+      try {
+        if (existsSync('package.json')) {
+          const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+          console.log(`Version: ${color.bold(pkg.version)}`);
+        }
+      } catch {
+        // Ignore if version can't be read
+      }
+      
       return `  Commands are loaded from exported functions in ${color.bold(BUNOSHFILE)}`;
     },
-    commandUsage: usg => 'bunosh <command> <args> [options]',
+    commandUsage: usg => 'bunosh [-e <code>] <command> <args> [options]',
     showGlobalOptions: false,
     visibleGlobalOptions: _opt => [],
     visibleOptions: _opt => [],
     visibleCommands: cmd => {
       const commands = cmd.commands.filter(c => !internalCommands.includes(c));
-      return commands.filter(c => !c.name().startsWith('npm:'));
+      return commands.filter(c => !c.name().startsWith('npm:') && !c.name().startsWith('my:'));
     },
     subcommandTerm: (cmd) => color.white.bold(cmd.name()),
     subcommandDescription: (cmd) => color.gray(cmd.description()),
@@ -65,8 +113,9 @@ export default function bunosh(commands, source) {
   }
 
   const comments = fetchComments();
+  const homeComments = fetchHomeComments();
 
-  // Collect all commands (bunosh + npm scripts) and sort them
+  // Collect all commands (bunosh + personal commands + npm scripts) and sort them
   const allCommands = [];
 
   // Add bunosh commands
@@ -74,6 +123,13 @@ export default function bunosh(commands, source) {
     allCommands.push({ type: 'bunosh', name: fnName, data: commands[fnName] });
   });
 
+  // Add personal commands with my: prefix
+  Object.keys(homeTasks).forEach((fnName) => {
+    if (typeof homeTasks[fnName] === 'function') {
+      allCommands.push({ type: 'home', name: `my:${fnName}`, data: homeTasks[fnName], source: homeSource });
+    }
+  });
+
   // Add npm scripts
   Object.entries(npmScripts).forEach(([scriptName, scriptCommand]) => {
     allCommands.push({ type: 'npm', name: `npm:${scriptName}`, data: { scriptName, scriptCommand } });
@@ -221,6 +277,57 @@ export default function bunosh(commands, source) {
 
         return functionOpts;
       }
+    } else if (cmdData.type === 'home') {
+      // Handle personal commands with my: prefix
+      const originalFnName = cmdData.name.replace('my:', ''); // Remove my: prefix for internal usage
+      const fnBody = cmdData.data.toString();
+      const homeAst = fetchHomeFnAst(originalFnName, cmdData.source);
+      const homeArgs = parseHomeArgs(originalFnName, homeAst);
+      const homeOpts = parseHomeOpts(originalFnName, homeAst);
+      const homeComment = homeComments[originalFnName];
+
+      const commandName = cmdData.name; // Keep the full my: prefix for command name
+
+      const command = program.command(commandName);
+      command.hook('preAction', (_thisCommand) => {
+        process.env.BUNOSH_COMMAND_STARTED = true;
+      });
+
+      let argsAndOptsDescription = [];
+
+      Object.entries(homeArgs).forEach(([arg, value]) => {
+        if (value === undefined) {
+          argsAndOptsDescription.push(`<${arg}>`);
+          return command.argument(`<${arg}>`);
+        }
+
+        if (value === null) {
+          argsAndOptsDescription.push(`[${arg}]`);
+          return command.argument(`[${arg}]`, '', null);
+        }
+
+        argsAndOptsDescription.push(`[${arg}=${value}]`);
+        command.argument(`[${arg}]`, ``, value);
+      });
+
+      Object.entries(homeOpts).forEach(([opt, value]) => {
+        if (value === false || value === null) {
+          argsAndOptsDescription.push(`--${opt}`);
+          return command.option(`--${opt}`);
+        }
+
+        argsAndOptsDescription.push(`--${opt}=${value}`);
+        command.option(`--${opt} [${opt}]`, "", value);
+      });
+
+      let description = homeComment?.split('\n')[0] || '';
+
+      if (homeComment && argsAndOptsDescription.length) {
+        description += `\n  ${color.gray(`bunosh ${commandName}`)} ${color.blue(argsAndOptsDescription.join(' ').trim())}`;
+      }
+
+      command.description(description);
+      command.action(cmdData.data.bind(homeTasks));
     } else if (cmdData.type === 'npm') {
       // Handle npm scripts
       const { scriptName, scriptCommand } = cmdData.data;
@@ -252,15 +359,14 @@ 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(async () => {
-      try {
-        await openEditor([{
-          file: BUNOSHFILE,
-        }]);
-      } catch (error) {
-        console.error(error.message);
-        console.error('Set $EDITOR environment variable to use a different editor');
+      if (!Bun) {
+        console.log('Bun is not available');
         process.exit(1);
+        return;
       }
+      await Bun.openEditor([{
+        file: BUNOSHFILE,
+      }]);
     });
 
   internalCommands.push(editCmd);
@@ -312,7 +418,7 @@ export default function bunosh(commands, source) {
         const paths = getCompletionPaths(shell);
 
         // Check if already installed
-        if (!options.force && fs.existsSync(paths.completionFile)) {
+        if (!options.force && existsSync(paths.completionFile)) {
           console.log(`⚠️  Completion already installed at: ${paths.completionFile}`);
           console.log('   Use --force to overwrite, or run:');
           console.log(`   ${color.dim('rm')} ${paths.completionFile}`);
@@ -437,6 +543,23 @@ export default function bunosh(commands, source) {
 
   internalCommands.push(upgradeCmd);
 
+  // Add personal commands help section if personal commands exist
+  const homeTaskNamesForHelp = Object.keys(homeTasks).filter(key => typeof homeTasks[key] === 'function');
+  if (homeTaskNamesForHelp.length > 0) {
+    const homeCommandsList = homeTaskNamesForHelp.sort().map(taskName => {
+      const commandName = `my:${taskName}`;
+      const taskComment = homeComments[taskName] || '';
+      const description = taskComment ? taskComment.split('\n')[0] : 'Personal command';
+      return `  ${color.white.bold(commandName.padEnd(18))} ${color.gray(description)}`;
+    }).join('\n');
+
+    program.addHelpText('after', `
+
+My Commands (from ~/${BUNOSHFILE}):
+${homeCommandsList}
+`);
+  }
+
   // Add npm scripts help section if npm scripts exist
   const npmScriptNamesForHelp = Object.keys(npmScripts);
   if (npmScriptNamesForHelp.length > 0) {
@@ -460,6 +583,10 @@ Special Commands:
   📝 Edit bunosh file: ${color.bold('bunosh edit')}
   📥 Export commands as scripts to package.json: ${color.bold('bunosh export:scripts')}
   🦾 Upgrade bunosh: ${color.bold('bunosh upgrade')}
+  
+Execute JavaScript:
+  ${color.bold('bunosh -e "console.log(\'Hello\')"')}    Execute inline JavaScript
+  ${color.bold('bunosh -e < script.js')}                 Execute JavaScript from file
 `);
 
   program.on("command:*", (cmd) => {
@@ -467,6 +594,12 @@ Special Commands:
     program.outputHelp();
   });
 
+  // Show help if no command provided
+  if (process.argv.length === 2) {
+    program.outputHelp();
+    return program;
+  }
+
   program.parse(process.argv);
 
   function fetchComments() {
@@ -509,6 +642,150 @@ Special Commands:
 
     return comments;
   }
+
+  function fetchHomeComments() {
+    if (!homeSource) return {};
+    
+    const homeComments = {};
+    let homeCompleteAst;
+    
+    try {
+      homeCompleteAst = babelParser.parse(homeSource, {
+        sourceType: "module",
+        ranges: true,
+        tokens: true,
+        comments: true,
+        attachComment: true,
+      });
+    } catch (parseError) {
+      console.warn('Warning: Could not parse home Bunoshfile for comments:', parseError.message);
+      return {};
+    }
+
+    let startFromLine = 0;
+
+    traverse(homeCompleteAst, {
+      FunctionDeclaration(path) {
+        const functionName = path.node.id && path.node.id.name;
+
+        const commentSource = homeSource
+          .split("\n")
+          .slice(startFromLine, path.node?.loc?.start?.line)
+          .join("\n");
+        const matches = commentSource.match(
+          /\/\*\*\s([\s\S]*)\\*\/\s*export/,
+        );
+
+        if (matches && matches[1]) {
+          homeComments[functionName] = matches[1]
+            .replace(/^\s*\*\s*/gm, "")
+            .replace(/\s*\*\*\s*$/gm, "")
+            .trim()
+            .replace(/^@.*$/gm, "")
+            .trim();
+        } else {
+          // Check for comments attached to the first statement in the function body
+          const firstStatement = path.node?.body?.body?.[0];
+          const leadingComments = firstStatement?.leadingComments;
+
+          if (leadingComments && leadingComments.length > 0) {
+            homeComments[functionName] = leadingComments[0].value.trim();
+          }
+        }
+
+        startFromLine = path.node?.loc?.end?.line;
+      },
+    });
+
+    return homeComments;
+  }
+
+  function fetchHomeFnAst(fnName, source) {
+    try {
+      return babelParser.parse(source, {
+        sourceType: "module",
+        ranges: true,
+        tokens: true,
+        comments: true,
+        attachComment: true,
+      });
+    } catch (parseError) {
+      console.warn('Warning: Could not parse home function AST:', parseError.message);
+      return null;
+    }
+  }
+
+  function parseHomeArgs(fnName, ast) {
+    if (!ast) return {};
+    
+    const functionArguments = {};
+
+    traverse(ast, {
+      FunctionDeclaration(path) {
+        if (path.node.id.name !== fnName) return;
+
+        const params = path.node.params
+          .filter((node) => {
+            return node?.right?.type !== "ObjectExpression";
+          })
+          .forEach((param) => {
+            if (param.type === "AssignmentPattern") {
+              functionArguments[param.left.name] = param.right.value;
+              return;
+            }
+            if (!param.name) return;
+
+            return functionArguments[param.name] = null;
+          });
+      },
+    });
+
+    return functionArguments;
+  }
+
+  function parseHomeOpts(fnName, ast) {
+    if (!ast) return {};
+    
+    let functionOpts = {};
+
+    traverse(ast, {
+      FunctionDeclaration(path) {
+        if (path.node.id.name !== fnName) return;
+
+        const node = path.node.params.pop();
+        if (!node) return;
+        if (
+          !node.type === "AssignmentPattern" &&
+          node.right.type === "ObjectExpression"
+        )
+          return;
+
+        node?.right?.properties?.forEach((p) => {
+          if (
+            ["NumericLiteral", "StringLiteral", "BooleanLiteral"].includes(
+              p.value.type,
+            )
+          ) {
+            functionOpts[camelToDasherize(p.key.name)] = p.value.value;
+            return;
+          }
+
+          if (p.value.type === "NullLiteral") {
+            functionOpts[camelToDasherize(p.key.name)] = null;
+            return;
+          }
+
+          if (p.value.type == "UnaryExpression" && p.value.operator == "!") {
+            functionOpts[camelToDasherize(p.key.name)] =
+              !p.value.argument.value;
+            return;
+          }
+        });
+      },
+    });
+
+    return functionOpts;
+  }
 }
 
 function prepareCommandName(name) {
@@ -541,17 +818,17 @@ function parseDocBlock(funcName, code) {
 }
 
 function exportFn(commands) {
-  if (!fs.existsSync(BUNOSHFILE)) {
+  if (!existsSync(BUNOSHFILE)) {
     console.error(`${BUNOSHFILE} file not found, can\'t export its commands.`);
     return false;
   }
 
-  if (!fs.existsSync('package.json')) {
+  if (!existsSync('package.json')) {
     console.error('package.json now found, can\'t set scripts.');
     return false;
   }
 
-  const pkg = JSON.parse(fs.readFileSync('package.json').toString());
+  const pkg = JSON.parse(readFileSync('package.json').toString());
   if (!pkg.scripts) {
     pkg.scripts = {};
   }
@@ -564,7 +841,7 @@ function exportFn(commands) {
 
   pkg.scripts = {...pkg.scripts, ...scripts };
 
-  fs.writeFileSync('package.json', JSON.stringify(pkg, null, 4));
+  writeFileSync('package.json', JSON.stringify(pkg, null, 4));
 
   console.log('Added scripts:');
   console.log();
@@ -579,11 +856,11 @@ function exportFn(commands) {
 
 function loadNpmScripts() {
   try {
-    if (!fs.existsSync('package.json')) {
+    if (!existsSync('package.json')) {
       return {};
     }
 
-    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
     const scripts = pkg.scripts || {};
 
     // Filter out bunosh scripts (scripts that contain "bunosh")
@@ -600,3 +877,26 @@ function loadNpmScripts() {
     return {};
   }
 }
+
+// Load personal commands from user's home directory
+async function loadHomeTasks() {
+  try {
+    const os = await import('os');
+    const path = await import('path');
+    const homeDir = os.homedir();
+    const homeBunoshfile = path.join(homeDir, BUNOSHFILE);
+
+    if (!existsSync(homeBunoshfile)) {
+      return { tasks: {}, source: '' };
+    }
+
+    // Import the home Bunoshfile
+    const homeTasks = await import(homeBunoshfile);
+    const homeSource = readFileSync(homeBunoshfile, 'utf-8');
+
+    return { tasks: homeTasks, source: homeSource };
+  } catch (error) {
+    console.warn('Warning: Could not load personal commands:', error.message);
+    return { tasks: {}, source: '' };
+  }
+}