bunosh 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# bunosh
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.0.20. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/bunosh.tasks.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+import { exec, fetch, task, ignoreFail } from "./index";
+import { ask, say, yell } from "./io";
+import fs from "fs";
+import { writeToFile } from "./files";
+
+/**
+ * Builds binary file for Bunosh
+ */
+export async function buildBinary() {
+  await exec`bun build ./run.js --compile --outfile bunosh`;  
+}
+
+/**
+ * 🎉 Hello world
+ * @param {*} arg1
+ * @param {*} opts
+ */
+export async function helloWorld(
+  arg1,
+  opts = { user: null, val: "ok", flag: false },
+) {
+  // console.log("Hello World!", arg1);
+  yell("I need all git status");
+  const pack = await task('read file', () => {
+    return fs.readFileSync("package.json").toString();
+  });
+  say(pack);
+  writeToFile('test.txt', l => {
+    l`lock file`
+    l('Hello world');
+    l.fromFile('package.json');
+  });
+  yell('done');
+  yell('ok');
+}
+
+/**
+ * Hello other
+ */
+export async function helloOther(opts = {
+  user: null,
+  val: "ok",
+  flag: false
+}) {
+  
+  yell('running everything!')
+
+  await fetch('https://reqres.in/api/users')
+
+  await Promise.all([
+    fetch('https://reqres.in/api/users/1'),
+    exec`ps aux | grep redis`,
+    fetch('https://reqres.in/api/users/2')
+  ])
+
+  ignoreFail(true);
+
+  await exec`ps aux | grep node`,
+  await exec`git status`.cwd('/home/davert/projects/codeceptjs');
+}
+
+/**
+ * Deploys code to staging
+*/
+export async function updateToProduction() {
+  
+  await Promise.all([
+    exec`ps aux | grep redis`,    
+    exec`ps aux | grep clickhouse`,
+    fetch('https://reqres.in/api/users/2'),
+  ])
+}
+
+/**
+ * Deploys code to production
+ */
+export async function updateToStaging() {
+  // this is not ok
+  const env = await ask('Which environment we are in?');
+  say(env);
+}
+

package/files.js

@@ -0,0 +1,3 @@
+import writeToFile from "./src/tasks/writeToFile";
+
+export { writeToFile };

package/index.js

@@ -0,0 +1,15 @@
+import program from "./src/program";
+import exec from "./src/tasks/exec";
+import fetch from "./src/tasks/fetch";
+import { task, stopOnFail, ignoreFail } from "./src/task";
+
+export { program as bunosh };
+
+export { exec, fetch, task, stopOnFail, ignoreFail};
+export { exec as $ }
+
+export function buildCmd(cmd) {
+  return function(args) {
+    return exec`${cmd} ${args}`
+  }
+}

package/io.jsx

@@ -0,0 +1,47 @@
+import React, {useState, useEffect} from 'react';
+import { Box, Text } from 'ink';
+import { renderOnce, isStaticOutput} from './src/output';
+import Gradient from 'ink-gradient';
+import BigText from 'ink-big-text';
+import inquirer from 'inquirer';
+
+export function say(...args) {
+  if (isStaticOutput) {
+    console.log(...args);
+    return;
+  };
+
+  const colors = ['yellow', 'magenta', 'cyan', 'blue', 'blueBright', 'magentaBright', 'cyanBright', 'whiteBright'];
+
+  renderOnce(
+    <Box gap={1} height={20} overflow='hidden' >
+      <Text color='white'>!</Text>
+      {args.map((arg, i) => <Text color={colors[i]} key={i}>{arg}</Text>)}
+    </Box>
+  );
+}
+
+export async function ask(question, opts = {}) {
+
+  const answers = await inquirer.prompt({ name: question, message: question, ...opts })
+
+  return Object.values(answers)[0];
+}
+
+export function yell(text) {
+  if (isStaticOutput) {
+    console.log();
+    console.log(text.toUpperCase());
+    console.log();
+    return;
+  };
+
+  renderOnce(
+    <Box gap={1} marginLeft={1}>
+      <Gradient name="teen">
+        <BigText text={text}/>
+      </Gradient>
+
+    </Box>
+  );
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "bunosh",
+  "version": "0.1.0",
+  "module": "index.js",
+  "bin": {
+    "bunosh": "./run.js"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "^3.2.4",
+    "lint-staged": "^15.2.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "^7.23.7",
+    "cfonts": "^3.2.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "debug": "^4.3.4",
+    "fs-extra": "^11.2.0",
+    "ink": "^4.4.1",
+    "ink-big-text": "^2.0.0",
+    "ink-gradient": "^3.0.0",
+    "ink-spinner": "^5.0.0",
+    "inquirer": "^9.2.13",
+    "open-editor": "^4.1.1",
+    "picocolors": "^1.0.0",
+    "react": "^18.2.0",
+    "timer-node": "^5.0.7"
+  },
+  "lint-staged": {
+    "*.{js,css,md}": "prettier --write"
+  },
+  "scripts": {
+    "hello:other": "bunosh hello:other",
+    "hello:world": "bunosh hello:world",
+    "update:to-production": "bunosh update:to-production",
+    "update:to-staging": "bunosh update:to-staging"
+  }
+}

package/run.js

@@ -0,0 +1,30 @@
+
+import program, { BUNOSHFILE, banner }  from "./src/program";
+import { existsSync, readFileSync } from "fs";
+import init from "./src/init";
+import { say, yell } from './io';
+
+const tasksFile = `./${BUNOSHFILE}`;
+
+if (!existsSync(tasksFile)) {
+  console.log(banner);
+
+  if (process.argv.includes('init')) {
+    init();
+    process.exit(0);
+  }
+
+  console.log();
+  console.error(`Bunosh file not found: ${tasksFile}`);
+  console.log("Run `bunosh init` to create a new bunosh tasks file here")
+  console.log();
+  process.ar
+  process.exit(1);
+}
+
+global.say = say;
+global.yell = yell;
+
+import(tasksFile).then((tasks) => {
+  program(tasks, readFileSync(tasksFile, "utf-8"));
+});

package/src/init.js

@@ -0,0 +1,16 @@
+import { BUNOSHFILE } from "./program";
+import color from "picocolors";
+import fs from "fs";
+import templateFile from "../templates/init";
+
+export default function init() {
+  if (!fs.existsSync(BUNOSHFILE)) {
+    fs.writeFileSync(BUNOSHFILE, templateFile());
+    console.log(color.bold(`🎉 Bunosh ${BUNOSHFILE} file created`));
+    console.log('   Edit it with "bunosh edit" command');
+    console.log('   Or open it in your favorite editor');
+    return;
+  }
+
+  console.error(`Bunosh file already exists: ${BUNOSHFILE}`);
+}

package/src/output.js

@@ -0,0 +1,37 @@
+import { render as inkRender } from 'ink';
+import debug from 'debug';
+
+export const isStaticOutput = process.env.CI || process.env.DEBUG || !process.stdout.isTTY;
+
+if (isStaticOutput) debug.enable('bunosh:*');
+
+let renderer = null;
+
+export function render(comp = <></>) {
+  
+  if (!renderer) {
+    renderer = inkRender(comp);
+    return renderer;
+  }
+
+  renderer.rerender(comp);
+  return renderer;
+}
+
+export async function renderOnce(comp) {
+  if (renderer) await renderer.waitUntilExit();
+  render(comp);
+  clearRenderer();
+}
+
+export function clearRenderer() {
+  if (!renderer) return;
+  renderer.unmount();
+  renderer = null;
+}
+
+
+export function debugTask(task, line) {
+  const ns = `bunosh:${task}`;
+  debug(ns)(line);
+}

package/src/program.js

@@ -0,0 +1,327 @@
+const { Command } = require("commander");
+import babelParser from "@babel/parser";
+import traverse from "@babel/traverse";
+import color from "chalk";
+import fs from 'fs';
+import openEditor from 'open-editor';
+import banner from '../templates/banner';
+
+export const BUNOSHFILE = `bunosh.tasks.js`;
+
+export { banner };
+
+export default function bunosh(commands, source) {
+  const program = new Command();
+
+  const internalCommands = [];
+
+  program.configureHelp({
+    commandDescription: _cmd => `${banner}\n  Commands are loaded from ${color.bold(BUNOSHFILE)} as JS functions`,
+    commandUsage: usg => 'bunosh <command> <args> [options]',
+    showGlobalOptions: false,
+    // visibleArguments: cmd => cmd.registeredArguments,
+    visibleGlobalOptions: _opt => [],
+    // Bunosh has no default options
+    visibleOptions: _opt => [],
+    visibleCommands: cmd => cmd.commands.filter(c => !internalCommands.includes(c)),
+    // commandDescription: _opt => '',
+    // argumentTerm: (arg) => color.gray("aaa"),
+    subcommandTerm: (cmd) => pickColorForColorName(cmd.name()),
+    subcommandDescription: (cmd) => cmd.description(),
+  });
+
+  program.showHelpAfterError();
+  program.showSuggestionAfterError(true);
+  program.addHelpCommand(false);
+
+  const completeAst = babelParser.parse(source, {
+    sourceType: "module",
+    plugins: ["jsx"],
+    ranges: true,
+    tokens: true,
+    comments: true,
+    attachComment: true,
+  });
+
+  const comments = fetchComments();
+
+  Object.keys(commands).forEach((fnName) => {
+    const fnBody = commands[fnName].toString();
+
+    const ast = fetchFnAst();
+
+    const args = parseArgs();
+    const opts = parseOpts();
+    const comment = comments[fnName];
+
+    const command = program.command(prepareCommandName(fnName));
+    command.hook('preAction', (thisCommand) => {
+      process.env.BUNOSH_COMMAND_STARTED = true;
+    })
+    
+    args.filter(a => !!a).forEach((arg) => {
+      command.argument(`<${arg}>`);
+    });
+    Object.entries(opts).forEach(([opt, value]) => {
+      if (value === false || value === null) command.option(`--${opt}`);
+      command.option(`--${opt} [${opt}]`, "", value);
+    });
+
+    let description = comment || '';  
+    
+    let argsAndOpts = '';
+    if (args.length > 0) argsAndOpts += `${args.map(a => color.blueBright(`<${a}>`)).join(' ')}`
+    if (Object.keys(opts).length > 0) argsAndOpts += ` ${Object.keys(opts).map(opt => color.blueBright(`--${opt}`)).join(' ')}`    
+    if (comment && argsAndOpts) description += `\n  ${argsAndOpts.trim()}\n`;
+
+    command.description(description);
+    command.action(commands[fnName].bind(commands));
+
+    // We either take the ast from the file or we parse the function body
+    function fetchFnAst() {
+      let hasFnInSource = false;
+
+      traverse(completeAst, {
+        FunctionDeclaration(path) {
+          if (path.node.id.name == fnName) {
+            hasFnInSource = true;
+            return;
+          }
+        },
+      });
+
+      if (hasFnInSource) return completeAst;
+
+      return babelParser.parse(fnBody, { comment: true, tokens: true });
+    }
+
+    // We parse command args from function args
+    function parseArgs() {
+      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";
+            })
+            .map((param) => param.name);
+
+          functionArguments.push(params);
+        },
+      });
+
+      return functionArguments.flat();
+    }
+
+    // We parse command options from the object of last function args
+    function parseOpts() {
+      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;
+            }
+            // ignore other options for now
+          });
+        },
+      });
+
+      return functionOpts;
+    }
+  });
+
+  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',
+      });
+    });
+
+  internalCommands.push(editCmd);
+
+  const exoprtCmd = program.command('export:scripts')
+    .description('Export commands to "scripts" section of package.json.')
+    .action(() => {
+
+      exportFn(Object.keys(commands));
+    });
+    
+  internalCommands.push(exoprtCmd);    
+
+  program.addHelpText('after', `
+Example call:
+  bunosh ${program.commands.find(c => !internalCommands.includes(c)).name()} ${color.gray('<args>')} ${color.gray('[options]')}
+
+Special Commands:
+  📝 Edit bunosh file: ${color.bold('bunosh edit')}
+  📥 Export scripts to package.json: ${color.bold('bunosh export:scripts')}
+
+`);
+
+
+  program.on("command:*", (cmd) => {
+    console.log(`\nUnknown command ${cmd}\n`);
+    program.outputHelp();
+  });
+
+  program.parse(process.argv);
+
+  function fetchComments() {
+    const comments = {};
+
+    let startFromLine = 0;
+
+    traverse(completeAst, {
+      FunctionDeclaration(path) {
+        const functionName = path.node.id && path.node.id.name;
+
+        const commentSource = source
+          .split("\n")
+          .slice(startFromLine, path.node?.loc?.start?.line)
+          .join("\n");
+        const matches = commentSource.match(
+          /\/\*\*\s([\s\S]*)\\*\/\s*export/,
+        );
+
+        if (matches && matches[1]) {
+          comments[functionName] = matches[1]
+            .replace(/^\s*\*\s*/gm, "") // remove * chars
+            .trim()
+            .replace(/^@.*$/gm, "") // remove params from description
+            .trim();
+        } else {
+          const innerComments = path.node?.body?.innerComments;
+
+          if (innerComments && innerComments.length > 0) {
+            comments[functionName] = innerComments[0].value.trim();
+          }
+        }
+
+        startFromLine = path.node?.loc?.end?.line;
+      },
+    });
+
+    return comments;
+  }
+}
+
+function prepareCommandName(name) {
+  name = name
+    .split(/(?=[A-Z])/)
+    .join("-")
+    .toLowerCase();
+  return name.replace("-", ":");
+}
+
+function camelToDasherize(camelCaseString) {
+  return camelCaseString.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+function pickColorForColorName(commandName) {
+  const colors = [
+    color.red,
+    color.green,
+    color.yellow,
+    color.blue,
+    color.magenta,
+    color.cyan,
+  ];
+
+  const prefixName = camelToDasherize(commandName).split("-")[0];
+
+  const index =
+    prefixName.split("").reduce((acc, char) => {
+      return acc + char.charCodeAt(0);
+    }, 0) % colors.length;
+
+  return color.bold(colors[index](commandName));
+}
+
+function parseDocBlock(funcName, code) {
+  const regex = new RegExp(
+    `\\/\\*\\*([\\s\\S]*?)\\*\\/\\s*export\\s+function\\s+${funcName}\\s*\\(`,
+  );
+  const match = code.match(regex);
+
+  if (match && match[1]) {
+    // Remove leading asterisks and trim the result
+    return match[1]
+      .replace(/^\s*\*\s*/gm, "")
+      .split("\n")[0]
+      .trim();
+  }
+
+  return null;
+}
+
+function exportFn(commands) {
+  if (!fs.existsSync(BUNOSHFILE)) {
+    console.error(`${BUNOSHFILE} file not found, can\'t export its commands.`);
+    return false;
+  }
+
+  if (!fs.existsSync('package.json')) {
+    console.error('package.json now found, can\'t set scripts.');
+    return false;
+  }
+
+  const pkg = JSON.parse(fs.readFileSync('package.json').toString());
+  if (!pkg.scripts) {
+    pkg.scripts = {};
+  }
+  
+  // cleanup from previously exported
+  for (let s in pkg.scripts ) {
+    if (pkg[s] && pkg[s].startsWith('bunosh')) delete pkg[s];
+  }
+
+  const scripts = Object.fromEntries(commands.map(prepareCommandName).map(k => [k, 'bunosh '+k]));
+
+  pkg.scripts = {...pkg.scripts, ...scripts };
+
+  fs.writeFileSync('package.json', JSON.stringify(pkg, null, 4));
+
+  console.log('Added scripts:');
+  console.log();
+
+  Object.keys(scripts).forEach(k => console.log('   bun run ' + k));
+
+  console.log();
+  console.log('package.json updated');
+  console.log(`${Object.keys(scripts).length} scripts exported`);
+  return true;
+}

package/src/task.jsx

@@ -0,0 +1,209 @@
+import React, {useState, useEffect} from 'react';
+import { Text, Box } from 'ink';
+import Spinner from 'ink-spinner';
+import { Timer } from 'timer-node';
+import { render, clearRenderer, renderOnce } from './output';
+
+export const TaskStatus = {  
+  RUNNING: 'running',
+  FAIL: 'fail',
+  SUCCESS: 'success'
+};
+
+export const tasksExecuted = [];
+
+
+let activeComponents = [];
+let activeTasks = [];
+
+let stopFailToggle = true;
+
+export function stopOnFail(enable = true) {
+  stopFailToggle = enable;
+}
+
+export function ignoreFail(enable = true) {
+  stopFailToggle = !enable;
+}
+
+const globalTimer = new Timer({ label: 'global', precision: 'ms'});
+globalTimer.start();
+process.on('exit', (code) => {
+  // we don't need this banner if no tasks were executed
+  if (!process.env.BUNOSH_COMMAND_STARTED) return;
+
+  globalTimer.stop();
+  const success = code === 0;
+  const tasksFailed = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.FAIL).length;
+  renderOnce(<Box flexDirection='row' gap={2}>
+    <Text bold backgroundColor={!success && 'red'}>🍲
+      {success ? '' : 'FAIL '}
+    </Text>
+    <Text dimColor >Exit Code: <Text bold color={code === 0 ? 'green' : 'red'}>{code}</Text></Text>
+    <Text dimColor>Tasks executed: <Text bold>{tasksExecuted.length}</Text></Text>
+    {!!tasksFailed && <Text dimColor>Tasks failed: <Text bold color="red">{tasksFailed}</Text></Text>}
+    <Text dimColor>Time: <Text bold>{globalTimer.ms()}</Text>ms</Text>
+  </Box>);
+});
+
+export async function task(name, fn) {
+  let fnResult = null;
+
+  if (!fn) {
+    fn = name;
+    name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
+  }
+
+  const promise = Promise.resolve(fn()).then((ret) => {
+    fnResult = ret;
+    return TaskResult.success(ret);
+  }).catch((err) => {    
+    return TaskResult.fail(err);
+  });
+  const taskInfo = new TaskInfo({ promise, kind: 'task', text: name });
+
+  const TaskOutput = () => {
+    const [output, setOutput] = useState(null);
+    useEffect(() => {
+      if (!fnResult?.toString) return;
+      promise.then(_ => setOutput(fnResult.toString()));
+    });
+
+    return <Box overflow='hidden' height={10} borderStyle="round" >
+      <Text dimColor={true}>{output}</Text>
+    </Box>
+  }
+  renderTask(taskInfo, <TaskOutput />);
+
+  await promise;
+  return fnResult;
+}
+
+function addToRender(comp) {
+  activeComponents.push(comp);
+  activeTasks.push(comp.props.taskInfo);
+    
+  if (activeComponents.length < 2) {
+    render(comp);
+    return;
+  }
+  render(<Box flexDirection='row' gap={1}>
+    {activeComponents}
+  </Box>);
+}
+
+function removeFromRender(taskInfo) {
+  activeTasks = activeTasks.filter((ti) => ti?.id !== taskInfo?.id);
+
+  if (activeTasks.length === 0) {
+    clearRenderer();
+    activeComponents = [];
+    return;
+  }
+}
+
+export const renderTask = async (taskInfo, children) => {
+  if (tasksExecuted.map(t => t.id).includes(taskInfo.id)) return; // alraday executed
+
+  tasksExecuted.push(taskInfo);
+  addToRender(<Task key={`${tasksExecuted.length}_${taskInfo}`} taskInfo={taskInfo}>{children}</Task>);
+};
+
+
+function Status({ taskStatus }) {
+  if (!taskStatus) return <Text dimColor>-</Text>;
+  if (taskStatus == TaskStatus.SUCCESS) return <Text color='green' bold>✓</Text>;
+  if (taskStatus == TaskStatus.FAIL) return <Text color='red' bold>×</Text>;
+}
+
+export const Task = ({ taskInfo, children }) => {
+  const timer = new Timer({ label: taskInfo.text, precision: 'ms'});
+
+  const [time, setTime] = useState(null);
+  const [status, setStatus] = useState(null);
+  
+  const { promise } = taskInfo;
+  timer.start();
+  
+  function updateTaskInfo(result) {
+    timer.stop();
+    taskInfo.result = result;
+    taskInfo.time = timer.ms();
+    setStatus(result.status);
+    setTime(timer.ms());
+    removeFromRender(taskInfo);
+
+    // hard exit, task has failed
+    if (result.status === TaskStatus.FAIL && stopFailToggle) {
+      process.exit(1);
+
+    }
+  }
+
+  useEffect(() => {    
+    promise.then((result) => {
+      updateTaskInfo(result)
+    }).catch((err) => {
+      updateTaskInfo(TaskResult.fail(err.toString()));
+    });
+  }, []);
+
+  return (<Box flexGrow={1} flexBasis="50%" flexDirection='column'>
+      <Box gap={1} flexDirection='row' alignItems='flex-start' justifyContent="flex-start">
+        <Status taskStatus={status} />
+
+        {taskInfo.titleComponent}
+
+        {taskInfo.extraText && <Text color='cyan' dimColor>{taskInfo.extraText}</Text>}
+
+        {time === null && <Spinner />}
+        {time !== null && <Text dimColor={true}>{time}ms</Text>}
+        
+      </Box>
+
+      {children}
+      </Box>
+  );
+};
+
+export class TaskInfo {
+  constructor({ promise, kind, text, extraText }) {
+    if (!kind) throw new Error('TaskInfo: kind is required');
+    if (!text) throw new Error('TaskInfo: text is required');
+
+    this.id = `${kind}-${text.slice(0,30).replace(/\s/g, '-')}-${Math.random().toString(36).substring(7)}`;
+    this.kind = kind;
+    this.text = text;
+    this.extraText = extraText;
+    this.promise = promise;
+    this.result = null;
+    this.time = null;
+  }
+
+  get titleComponent() {
+    return <>  
+      <Text bold>{this.kind}</Text>
+      <Text color='yellow'>{this.text}</Text>
+    </>;
+  }
+
+  toString() {
+    return `${this.kind} ${this.text}`;
+  }
+}
+
+export class TaskResult {
+  constructor({ status, output }) {
+    this.status = status;
+    this.output = output;
+  }
+
+  static fail(output = null) {
+    return new TaskResult({ status: TaskStatus.FAIL, output });
+  }
+
+  static success(output = null) {
+    return new TaskResult({ status: TaskStatus.SUCCESS, output });
+
+  }
+}

package/src/tasks/copyFile.jsx

@@ -0,0 +1,14 @@
+const { copySync } = require('fs-extra');
+import { task } from '../task.jsx';
+
+export default function copyFile(src, dst) {
+
+  task(`copy ${src} ⇒ ${dst}`, () => {
+    copySync(src, dst);
+  });
+
+}
+
+
+
+

package/src/tasks/exec.jsx

@@ -0,0 +1,87 @@
+import { $ } from "bun";
+import React, {useState, useEffect} from 'react';
+import { Text, Box } from 'ink';
+import { debugTask, isStaticOutput } from '../output.js';
+import { renderTask, TaskInfo, TaskResult } from '../task.jsx';
+
+const DEFAULT_OUTPUT_SIZE = 10;
+
+export default function exec(strings, ...values) {
+  
+  const cmd = strings.reduce((accumulator, str, i) => {
+    return accumulator + str + (values[i] || '');
+  }, '');
+
+  let resolve, reject;
+  const cmdPromise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  let envs = null
+  cmdPromise.env = (newEnvs) => envs = newEnvs;
+
+  let cwd = null;
+  cmdPromise.cwd = (newCwd) => cwd = newCwd;
+  
+  const ExecOutput = () => {
+    let shell = $(strings, ...values);
+    if (cwd) {
+      shell = shell.cwd(cwd);
+    } 
+    if (envs) {
+      shell = shell.env(envs);
+    }
+
+    const stackOutput = [];
+    
+    const [printedLines, setPrintedLines] = useState([]);
+    const [exitCode, setExitCode] = useState(null);
+
+    const readNextChunk = async () => {
+      for await (let line of shell.lines()) {
+        debugTask(cmd, line);
+        stackOutput.push(line);
+        setPrintedLines(stackOutput.slice(-DEFAULT_OUTPUT_SIZE));
+      }
+      const code = parseInt((await shell).exitCode, 10);
+      setExitCode(code);
+      if (code == 0) resolve(TaskResult.success(stackOutput.join('\n')));
+      if (code !== 0) resolve(TaskResult.fail(stackOutput.join('\n')));
+    };
+
+    useEffect(() => {
+      readNextChunk();
+    }, []);
+    
+    if (isStaticOutput) return <></>
+
+    return <>
+      <Box marginBottom={1} flexDirection="column">
+      {printedLines.length > 0 && <Box borderStyle="round" padding={1} flexDirection="column" >
+        {printedLines.map((line, i) => <Text wrap="truncate" key={i}>{line.trim()}</Text>)}
+      </Box>}
+      <Box>
+      {exitCode === 0 && <Text dimColor>Success! Exit code: {exitCode}</Text>}
+      {exitCode !== null && exitCode != 0 && <Text dimColor color="red">Failure! Exit code: <Text bold>{exitCode}</Text></Text>}
+      </Box>
+      </Box>
+    </>
+  }
+
+  setTimeout(() => {
+    let extraText = '';
+    if (cwd) extraText += `at ${cwd}`;
+    if (envs) extraText += ` with ${envs}`;
+
+    renderTask(new TaskInfo({
+      promise: cmdPromise,
+      kind: 'exec',
+      text: cmd,
+      extraText: extraText,
+    }), <ExecOutput />);
+  }, 0);
+
+  return cmdPromise;
+}
+

package/src/tasks/fetch.jsx

@@ -0,0 +1,74 @@
+import React, {useState, useEffect} from 'react';
+import { Text, Box } from 'ink';
+import { debugTask, isStaticOutput } from '../output.js';
+import { renderTask, TaskInfo, TaskResult } from '../task.jsx';
+
+
+const DEFAULT_OUTPUT_SIZE = 10;
+
+export default async function httpFetch() {
+  const textDecoder = new TextDecoder();
+
+  const url = arguments[0];
+  const method = arguments[1]?.method || 'GET';
+  const text = `${method} ${url}`;
+  
+  
+  let resolve, reject;
+  let promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  
+  const FetchOutput = () => {
+    const fetchPromise = fetch(...arguments);
+    
+
+    const stackOutput = [];
+    
+    const [response, setResponse] = useState(null);
+    const [printedLines, setPrintedLines] = useState([]);
+
+    useEffect(() => {
+      fetchPromise.then(async (response) => {
+        setResponse(response);
+
+        setPrintedLines(['a', 'b', 'c']);
+        for await (const chunk of response.body) {
+
+          const lines = textDecoder.decode(chunk, { stream: true }).toString().split('\n');
+          lines.forEach((line) => {
+            debugTask(text, line);
+            stackOutput.push(line);
+            setPrintedLines(stackOutput.slice(-DEFAULT_OUTPUT_SIZE));  
+          });          
+        }
+        
+        resolve(TaskResult.success(stackOutput.join('\n')));
+        resolve(TaskResult.fail(stackOutput.join('\n')));
+      });
+    }, []);
+    
+    if (isStaticOutput) return <></>
+
+    return <>
+      <Box marginBottom={1} flexDirection="column">
+      {printedLines && <Box borderStyle="round" padding={1} flexDirection="column" >
+        {printedLines.map((line, i) => <Text wrap="truncate" key={i}>{line.trim()}</Text>)}
+      </Box>}
+      <Box>
+      {response && response.ok && <Text dimColor>Success. Status: {response.statusText} ({response.status}) {response.headers.get('Content-Type')}</Text>}
+      {response && !response.ok && <Text dimColor color="red">Failure! Status: <Text bold>{response.statusText} ({response.status})</Text></Text>}
+      </Box>
+      </Box>
+    </>
+  }
+
+  renderTask(new TaskInfo({
+    promise,
+    kind: 'fetch',
+    text,
+  }), <FetchOutput />);
+
+  return promise;
+}

package/src/tasks/writeToFile.jsx

@@ -0,0 +1,49 @@
+import path from 'path';
+import fs from 'fs';
+import { task } from '../task.jsx';
+
+export default function writeToFile(fileName, lineBuilderFn) {
+
+  let text = '';
+
+  const fileLine = function(strings, ...values) {
+    if (strings instanceof Array) {
+      const line = strings.reduce((accumulator, str, i) => {
+        return accumulator + str + (values[i] || '');
+      }, '');
+      text += `${line}\n`;
+      return;
+
+    }
+
+    text += `${strings}\n`;
+  }
+
+  fileLine.fromFile = function(file) {
+    text += fs.readFileSync(path.join(process.cwd(), file));
+  }
+
+  fileLine.currentFile = function() {
+    text += fs.readFileSync(path.join(process.cwd(), fileName));
+  }
+
+  task(`write to file ${fileName}`, () => {
+
+    if (lineBuilderFn instanceof Function) {
+      lineBuilderFn(fileLine);
+    } else {
+      text += lineBuilderFn;
+    }
+    setTimeout(() => {
+      fs.writeFileSync(fileName, text);
+    }, 0);
+    // render text first before writing to file
+    return text;
+  });
+
+  return text;
+}
+
+
+
+

package/templates/banner.js

@@ -0,0 +1,12 @@
+import color from "picocolors";
+
+export default `
+─╔══╗──╔╗─╔╗─╔═╗─╔╗─╔═══╗─╔═══╗─╔╗─╔╗
+─║╔╗║──║║─║║─║║╚╗║║─║╔═╗║─║╔═╗║─║║─║║
+─║╚╝╚╗─║║─║║─║╔╗╚╝║─║║─║║─║╚══╗─║╚═╝║
+─║╔═╗║─║║─║║─║║╚╗║║─║║─║║─╚══╗║─║╔═╗║
+─║╚═╝║─║╚═╝║─║║─║║║─║╚═╝║─║╚═╝║─║║─║║
+─╚═══╝─╚═══╝─╚╝─╚═╝─╚═══╝─╚═══╝─╚╝─╚╝
+
+  🍲 ${color.bold(color.white('Bunosh'))} - your ${color.bold('exceptional')} task runner powered by Bun  
+`.trim();

package/templates/init.js

@@ -0,0 +1,29 @@
+
+export default () => `import { exec, fetch, ignoreFail } from "bunosh";
+import { say, yell } from "bunosh/io";
+import { writeToFile } from "bunosh/files";
+
+/**
+ * 🎉 Hello world command
+ */
+export async function helloWorld() {
+  // use say() to print to the console
+  // say("Hello World!");
+
+  // use exec`` to execute shell scripts:
+  // await exec\`git status\`
+
+  // use fetch() to make HTTP requests
+  // await fetch('https://reqres.in/api/users')
+
+  // 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/test.txt

@@ -0,0 +1,44 @@
+lock file
+Hello world
+{
+  "name": "bunosh",
+  "module": "index.js",
+  "bin": {
+    "bunosh": "./run.js"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "^3.2.4",
+    "lint-staged": "^15.2.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "^7.23.7",
+    "cfonts": "^3.2.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "debug": "^4.3.4",
+    "fs-extra": "^11.2.0",
+    "ink": "^4.4.1",
+    "ink-big-text": "^2.0.0",
+    "ink-gradient": "^3.0.0",
+    "ink-spinner": "^5.0.0",
+    "inquirer": "^9.2.13",
+    "open-editor": "^4.1.1",
+    "picocolors": "^1.0.0",
+    "react": "^18.2.0",
+    "timer-node": "^5.0.7"
+  },
+  "lint-staged": {
+    "*.{js,css,md}": "prettier --write"
+  },
+  "scripts": {
+    "hello:other": "bunosh hello:other",
+    "hello:world": "bunosh hello:world",
+    "update:to-production": "bunosh update:to-production",
+    "update:to-staging": "bunosh update:to-staging"
+  }
+}