bunosh 0.5.6 → 0.5.8

package/README.md

@@ -187,7 +187,7 @@ Bunoshfile.api.js    # bunosh api:deploy, bunosh api:test
 Built-in tasks are available via `global.bunosh`:
 
 ```javascript
-const { exec, shell, fetch, writeToFile, copyFile, task } = global.bunosh;
+const { exec, shell, fetch, writeToFile, copyFile, task, assert } = global.bunosh;
 ```
 
 > Global variables are used instead of imports so bunosh works with the single-executable on any platform.
@@ -195,6 +195,7 @@ const { exec, shell, fetch, writeToFile, copyFile, task } = global.bunosh;
 * Async tasks: `exec`, `shell`, `fetch`
 * Sync tasks: `writeToFile`, `copyFile`
 * Task wrapper: `task`
+* Precondition guard: `assert`
 
 Each task returns a `TaskResult` object:
 
@@ -273,6 +274,30 @@ For details see the [Bun shell](https://bun.sh/docs/runtime/shell) reference.
 | `exec` | Single command execution | spawn process | Node.js + Bun, platform dependent |
 | `shell` | Cross-platform shell commands | Bun shell | Bun only, cross-platform |
 
+### `assert`
+
+Guard a command on a precondition. If the condition is falsy, `assert` prints a red failure line and records a failed task — the run continues, and the process exits with code 1 at the end:
+
+```javascript
+export async function deploy() {
+  assert(process.env.TOKEN, 'TOKEN must be set');
+  assert(await Bun.file('dist/bundle.js').exists(), 'bundle not built');
+  await shell`./scripts/deploy.sh`;
+}
+```
+
+With `task.stopOnFailures()` enabled, a failed `assert` exits immediately at that line:
+
+```javascript
+export async function strict() {
+  task.stopOnFailures();
+  assert(process.env.TOKEN, 'TOKEN must be set');
+  await shell`./scripts/deploy.sh`;
+}
+```
+
+`assert` does not throw a JavaScript exception in default mode — it records the failure and execution continues. Use `task.stopOnFailures()` (or `return` after the `assert`) when you need a hard stop.
+
 ### `fetch`
 
 Wraps the fetch API as a task:

package/index.js

@@ -5,10 +5,11 @@ 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 assert from "./src/tasks/assert.js";
 import { ask, yell, say } from "./src/io.js";
 import { task, tryTask, stopOnFail, ignoreFail, stopOnFailures, ignoreFailures, silence, prints, silent, TaskResult } from "./src/task.js";
 
-export { exec, shell, fetch, writeToFile, copyFile, ai, ask, yell, say, task, tryTask, stopOnFail, ignoreFail, stopOnFailures, ignoreFailures, silence, prints, silent, TaskResult };
+export { exec, shell, fetch, writeToFile, copyFile, ai, assert, ask, yell, say, task, tryTask, stopOnFail, ignoreFail, stopOnFailures, ignoreFailures, silence, prints, silent, TaskResult };
 
 export function buildCmd(cmd) {
   return function (args) {
@@ -26,6 +27,7 @@ global.bunosh = {
   writeToFile,
   copyFile,
   ai,
+  assert,
   stopOnFail,
   ignoreFail,
   task,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Task runner that turns JavaScript functions into CLI commands. Runs on Bun and Node.js.",
   "type": "module",
   "module": "index.js",

package/src/task.js

@@ -47,6 +47,22 @@ export function getIgnoreFailuresMode() {
   return ignoreFailuresMode;
 }
 
+export function isStopOnFailuresMode() {
+  return stopOnFailuresMode;
+}
+
+export function isTestEnv() {
+  const commandArgs = process.argv.slice(2);
+  return process.env.NODE_ENV === 'test' ||
+    commandArgs.some(arg => {
+      const lower = arg.toLowerCase();
+      return lower.includes('vitest') ||
+             lower.includes('jest') ||
+             lower === '--test' ||
+             lower.startsWith('test:');
+    });
+}
+
 export function silence() {
   globalSilenceMode = true;
 }
@@ -222,24 +238,12 @@ export async function task(name, fn, isSilent = false) {
     printer.error(name, err);
     runningTasks.delete(taskInfo.id);
 
-    // Don't exit during testing
-    const commandArgs = process.argv.slice(2);
-    const isTestEnvironment = process.env.NODE_ENV === 'test' ||
-                              typeof Bun?.jest !== 'undefined' ||
-                              commandArgs.some(arg => {
-                                const lowerArg = arg.toLowerCase();
-                                return lowerArg.includes('vitest') ||
-                                       lowerArg.includes('jest') ||
-                                       lowerArg === '--test' ||
-                                       lowerArg.startsWith('test:');
-                              });
-
-    // Exit immediately if stopOnFailures mode is enabled
+    const isTestEnvironment = isTestEnv();
+
     if (stopOnFailuresMode && !isTestEnvironment) {
       process.exit(1);
     }
-    
-    // Also exit if stopFailToggle is enabled (legacy behavior)
+
     if (stopFailToggle && !isTestEnvironment) {
       process.exit(1);
     }

package/src/tasks/assert.js

@@ -0,0 +1,23 @@
+import { createTaskInfo, finishTaskInfo, getCurrentTaskId, runningTasks, isStopOnFailuresMode, isTestEnv } from '../task.js';
+import Printer from '../printer.js';
+
+export default function assert(condition, message = 'Assertion failed') {
+  const currentTaskId = getCurrentTaskId();
+  const parent = currentTaskId ? runningTasks.get(currentTaskId) : null;
+  const isParentSilent = parent?.isSilent || false;
+
+  const taskInfo = createTaskInfo(message, currentTaskId, isParentSilent);
+  const printer = new Printer('assert', taskInfo.id);
+
+  if (condition) {
+    printer.finish(message);
+    finishTaskInfo(taskInfo, true, null, message);
+    return;
+  }
+
+  const error = new Error(message);
+  printer.error(message, error);
+  finishTaskInfo(taskInfo, false, error, message);
+
+  if (isStopOnFailuresMode() && !isTestEnv()) process.exit(1);
+}

package/types.d.ts

@@ -34,8 +34,9 @@ declare global {
         copyFile(src: string, dst: string): void;
         stopOnFail(enable?: boolean): void;
         ignoreFail(enable?: boolean): void;
-        buildCmd(cmd: string): (args: string) => Promise<any>;       
+        buildCmd(cmd: string): (args: string) => Promise<any>;
         task(name: string | Function, fn?: Function): Promise<any>;
+        assert(condition: any, message?: string): asserts condition;
       };
     }
   }