bunosh 0.1.4 → 0.2.2

package/src/task.js

@@ -0,0 +1,148 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import Printer from './printer.js';
+
+export const TaskStatus = {
+  RUNNING: 'running',
+  FAIL: 'fail',
+  SUCCESS: 'success'
+};
+
+export const tasksExecuted = [];
+export const runningTasks = new Map();
+
+let taskCounter = 0;
+let stopFailToggle = true;
+const asyncLocalStorage = new AsyncLocalStorage();
+
+
+export function stopOnFail(enable = true) {
+  stopFailToggle = enable;
+}
+
+export function ignoreFail(enable = true) {
+  stopFailToggle = !enable;
+}
+
+const startTime = Date.now();
+
+process.on('exit', (code) => {
+  if (!process.env.BUNOSH_COMMAND_STARTED) return;
+
+  const totalTime = Date.now() - startTime;
+  const success = code === 0;
+  const tasksFailed = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.FAIL).length;
+
+  console.log(`\n🍲 ${success ? '' : 'FAIL '}Exit Code: ${code} | Tasks: ${tasksExecuted.length}${tasksFailed ? ` | Failed: ${tasksFailed}` : ''} | Time: ${totalTime}ms`);
+});
+
+export function getRunningTaskCount() {
+  return runningTasks.size;
+}
+
+export function getCurrentTaskId() {
+  return asyncLocalStorage.getStore();
+}
+
+export function getTaskPrefix(taskId) {
+  const taskNumber = Array.from(runningTasks.keys()).indexOf(taskId) + 1;
+  return getRunningTaskCount() > 1 ? `❰${taskNumber}❱` : '';
+}
+
+export function createTaskInfo(name) {
+  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
+  runningTasks.set(taskInfo.id, taskInfo);
+  tasksExecuted.push(taskInfo);
+  return taskInfo;
+}
+
+export function finishTaskInfo(taskInfo, success = true, error = null, output = null) {
+  const endTime = Date.now();
+  const duration = endTime - taskInfo.startTime;
+
+  taskInfo.status = success ? TaskStatus.SUCCESS : TaskStatus.FAIL;
+  taskInfo.duration = duration;
+  taskInfo.result = {
+    status: success ? TaskStatus.SUCCESS : TaskStatus.FAIL,
+    output: error?.message || output || null
+  };
+
+  runningTasks.delete(taskInfo.id);
+}
+
+export class TaskInfo {
+  constructor(name, startTime, status) {
+    this.id = `task-${++taskCounter}-${Math.random().toString(36).substring(7)}`;
+    this.name = name;
+    this.startTime = startTime;
+    this.status = status;
+  }
+}
+
+export async function task(name, fn) {
+  if (!fn) {
+    fn = name;
+    name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
+  }
+
+  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
+
+  tasksExecuted.push(taskInfo);
+  runningTasks.set(taskInfo.id, taskInfo);
+
+  const printer = new Printer('task', taskInfo.id);
+  printer.start(name);
+
+  try {
+    const result = await asyncLocalStorage.run(taskInfo.id, async () => {
+      return await Promise.resolve(fn());
+    });
+
+    const endTime = Date.now();
+    const duration = endTime - taskInfo.startTime;
+
+    taskInfo.status = TaskStatus.SUCCESS;
+    taskInfo.duration = duration;
+    taskInfo.result = { status: TaskStatus.SUCCESS, output: result };
+
+    printer.finish(name);
+    runningTasks.delete(taskInfo.id);
+
+    return result;
+  } catch (err) {
+    const endTime = Date.now();
+    const duration = endTime - taskInfo.startTime;
+
+    taskInfo.status = TaskStatus.FAIL;
+    taskInfo.duration = duration;
+    taskInfo.result = { status: TaskStatus.FAIL, output: err.message };
+
+    printer.error(name, err);
+    runningTasks.delete(taskInfo.id);
+
+    // Don't exit during testing
+    const isTestEnvironment = process.env.NODE_ENV === 'test' ||
+                              typeof Bun?.jest !== 'undefined' ||
+                              process.argv.some(arg => arg.includes('test'));
+
+    if (stopFailToggle && !isTestEnvironment) {
+      process.exit(1);
+    }
+
+    throw err;
+  }
+}
+
+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.js

@@ -0,0 +1,21 @@
+import fsExtra from 'fs-extra';
+const { copySync } = fsExtra;
+import Printer from '../printer.js';
+import { createTaskInfo, finishTaskInfo } from '../task.js';
+
+export default function copyFile(src, dst) {
+  const taskName = `${src} ⇒ ${dst}`;
+  const taskInfo = createTaskInfo(taskName);
+  const printer = new Printer('copyFile', taskInfo.id);
+  
+  try {
+    printer.start(taskName);
+    copySync(src, dst);
+    printer.finish(taskName);
+    finishTaskInfo(taskInfo, true, null, 'File copied');
+  } catch (error) {
+    printer.error(taskName, error);
+    finishTaskInfo(taskInfo, false, error, error.message);
+    throw error;
+  }
+}

package/src/tasks/exec.js

@@ -0,0 +1,204 @@
+import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import Printer from '../printer.js';
+
+const isBun = typeof Bun !== 'undefined';
+
+export default function exec(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;
+
+    const taskInfo = createTaskInfo(cmd);
+    const printer = new Printer('exec', taskInfo.id);
+    printer.start(cmd, extraInfo);
+
+    try {
+      if (global.disableBunForTesting || !isBun) {
+        const result = await nodeExec(cmd, extraInfo, printer, taskInfo);
+        if (result.status === 'success') {
+          finishTaskInfo(taskInfo, true, null, result.output);
+          resolve(result);
+        } else {
+          finishTaskInfo(taskInfo, false, new Error(result.output), result.output);
+          resolve(result);
+        }
+        return;
+      }
+
+      // Bun implementation with real-time streaming
+      const needsShell = cmd.includes('|') || cmd.includes('>') || cmd.includes('<') || cmd.includes('&&') || cmd.includes('||') || cmd.includes("'") || cmd.includes('"') || cmd.includes(';');
+
+      const { spawn } = Bun;
+      const proc = spawn({
+        cmd: needsShell ? ['/bin/sh', '-c', cmd] : cmd.trim().split(/\s+/),
+        cwd: cwd || process.cwd(),
+        env: {
+          ...(envs ? { ...process.env, ...envs } : process.env),
+        },
+        stdout: "pipe",
+        stderr: "pipe",
+        stdin: "ignore"
+      });
+
+      const decoder = new TextDecoder();
+      let output = '';
+      let finished = false;
+
+      // Process stdout
+      const readStdout = async () => {
+        const reader = proc.stdout.getReader();
+        let buffer = '';
+
+        try {
+          while (!finished) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            const text = decoder.decode(value, { stream: true });
+            buffer += text;
+
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+
+            for (const line of lines) {
+              if (line.trim()) {
+                printer.output(line);
+                output += line + '\n';
+              }
+            }
+          }
+
+          if (buffer.trim()) {
+            printer.output(buffer);
+            output += buffer + '\n';
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      };
+
+      // Process stderr
+      const readStderr = async () => {
+        const reader = proc.stderr.getReader();
+        let buffer = '';
+
+        try {
+          while (!finished) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            const text = decoder.decode(value, { stream: true });
+            buffer += text;
+
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+
+            for (const line of lines) {
+              if (line.trim()) {
+                printer.output(line, true);
+                output += line + '\n';
+              }
+            }
+          }
+
+          if (buffer.trim()) {
+            printer.output(buffer, true);
+            output += buffer + '\n';
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      };
+
+      // Start reading both streams
+      const [, , exitResult] = await Promise.all([
+        readStdout(),
+        readStderr(),
+        proc.exited
+      ]);
+
+      finished = true;
+      const exitCode = parseInt(exitResult, 10);
+
+      if (exitCode === 0) {
+        printer.finish(cmd);
+        finishTaskInfo(taskInfo, true, null, output.trim());
+        resolve(TaskResult.success(output.trim()));
+      } else {
+        const error = new Error(`Exit code: ${exitCode}`);
+        printer.error(cmd, null, { exitCode });
+        finishTaskInfo(taskInfo, false, error, output.trim());
+        resolve(TaskResult.fail(output.trim()));
+      }
+    } 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;
+}
+
+async function nodeExec(cmd, extraInfo, printer, taskInfo) {
+  // Node.js fallback - simple execution without real-time output
+  const { spawn } = await import('child_process');
+  
+  return new Promise((resolve) => {
+    const proc = spawn('sh', ['-c', cmd], {
+      cwd: extraInfo.cwd || process.cwd(),
+      env: extraInfo.env ? { ...process.env, ...extraInfo.env } : process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    
+    let output = '';
+    let errorOutput = '';
+    
+    proc.stdout.on('data', (data) => {
+      const text = data.toString();
+      printer.output(text.trim());
+      output += text;
+    });
+    
+    proc.stderr.on('data', (data) => {
+      const text = data.toString();
+      printer.output(text.trim(), true);
+      errorOutput += text;
+    });
+    
+    proc.on('close', (code) => {
+      const combinedOutput = (output + errorOutput).trim();
+      
+      if (code === 0) {
+        printer.finish(cmd);
+        resolve(TaskResult.success(combinedOutput));
+      } else {
+        printer.error(cmd, new Error(`Exit code: ${code}`));
+        resolve(TaskResult.fail(combinedOutput));
+      }
+    });
+    
+    proc.on('error', (error) => {
+      printer.error(cmd, error);
+      resolve(TaskResult.fail(error.message));
+    });
+  });
+}

package/src/tasks/fetch.js

@@ -0,0 +1,47 @@
+import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import Printer from '../printer.js';
+
+export default async function httpFetch() {
+  const url = arguments[0];
+  const method = arguments[1]?.method || 'GET';
+  const taskName = `${method} ${url}`;
+  
+  const taskInfo = createTaskInfo(taskName);
+  const printer = new Printer('fetch', taskInfo.id);
+  printer.start(taskName);
+
+  try {
+    const response = await fetch(...arguments);
+    const textDecoder = new TextDecoder();
+    let output = '';
+
+    if (response.body) {
+      for await (const chunk of response.body) {
+        const lines = textDecoder.decode(chunk, { stream: true }).toString().split('\n');
+        for (const line of lines) {
+          if (line.trim()) {
+            printer.print(line, 'output');
+            output += line + '\n';
+          }
+        }
+      }
+    }
+
+    if (response.ok) {
+      printer.finish(taskName, { status: `${response.status} ${response.statusText}` });
+      finishTaskInfo(taskInfo, true, null, output.trim());
+      return TaskResult.success(output.trim());
+    } else {
+      const errorMsg = `HTTP ${response.status} ${response.statusText}`;
+      const error = new Error(errorMsg);
+      printer.error(taskName, errorMsg);
+      finishTaskInfo(taskInfo, false, error, errorMsg);
+      return TaskResult.fail(errorMsg);
+    }
+    
+  } catch (error) {
+    printer.error(taskName, error);
+    finishTaskInfo(taskInfo, false, error, error.message);
+    return TaskResult.fail(error.message);
+  }
+}

package/src/tasks/{writeToFile.jsx → writeToFile.js}

@@ -1,9 +1,9 @@
 import path from 'path';
 import fs from 'fs';
-import { task } from '../task.jsx';
+import Printer from '../printer.js';
+import { createTaskInfo, finishTaskInfo } from '../task.js';
 
 export default function writeToFile(fileName, lineBuilderFn) {
-
   let text = '';
 
   const fileLine = function(strings, ...values) {
@@ -13,7 +13,6 @@ export default function writeToFile(fileName, lineBuilderFn) {
       }, '');
       text += `${line}\n`;
       return;
-
     }
 
     text += `${strings}\n`;
@@ -27,23 +26,26 @@ export default function writeToFile(fileName, lineBuilderFn) {
     text += fs.readFileSync(path.join(process.cwd(), fileName));
   }
 
-  task(`write to file ${fileName}`, () => {
-
+  const taskInfo = createTaskInfo(fileName);
+  const printer = new Printer('writeToFile', taskInfo.id);
+  
+  try {
+    printer.start(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;
-  });
+    
+    fs.writeFileSync(fileName, text);
+    printer.finish(fileName, { characters: text.length });
+    finishTaskInfo(taskInfo, true, null, `${text.length} characters`);
+  } catch (error) {
+    printer.error(fileName, error);
+    finishTaskInfo(taskInfo, false, error, error.message);
+    throw error;
+  }
 
   return text;
-}
-
-
-
-
+}