@stacksjs/actions 0.58.57 → 0.58.59

package/dist/src/build.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))

package/dist/src/bump.js

@@ -1,8 +1,14 @@
 // @bun
 // src/bump.ts
-import {runCommand} from "@stacksjs/cli";
+import {parseOptions, runCommand} from "@stacksjs/cli";
 import {path as p} from "@stacksjs/path";
-await runCommand("buddy changelog --quiet", {
+var options = parseOptions();
+var changelogCommand = options?.dryRun ? "buddy changelog --quiet --dry-run" : "buddy changelog --quiet";
+await runCommand(changelogCommand, {
   cwd: p.projectPath()
 });
-await runCommand("bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all", { cwd: p.frameworkPath(), stdin: "inherit" });
+var bumpCommand = options?.dryRun ? "bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --no-push" : "bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all";
+await runCommand(bumpCommand, {
+  cwd: p.frameworkPath(),
+  stdin: "inherit"
+});

package/dist/src/changelog.js

@@ -1,9 +1,17 @@
 // @bun
 // src/changelog.ts
-import {execSync, runCommand} from "@stacksjs/cli";
+import {execSync, log, parseOptions, runCommand} from "@stacksjs/cli";
 import {projectPath} from "@stacksjs/path";
+log.debug("Generating changelog");
 var fromRevision = await execSync("git describe --abbrev=0 --tags HEAD^");
+log.debug("FromRevision", fromRevision);
 var toRevision = await execSync("git describe");
-await runCommand(`bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`, {
-  cwd: projectPath()
+log.debug("ToRevision", toRevision);
+var options = parseOptions();
+log.debug("Changelog Options", options);
+var command = options?.dryRun ? `bunx changelogen --no-output --from ${fromRevision} --to ${toRevision}` : `bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`;
+await runCommand(command, {
+  cwd: projectPath(),
+  quiet: options?.quiet,
+  verbose: options?.verbose
 });

package/dist/src/dev/index.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))

package/dist/src/generate/index.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))

package/dist/src/helpers/index.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))

package/dist/src/helpers/utils.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))

package/dist/src/index.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))
@@ -254,7 +246,7 @@ async function installPackages(names) {
 
 // src/make.ts
 import process3 from "process";
-import {italic as italic2} from "@stacksjs/cli";
+import {italic} from "@stacksjs/cli";
 import {log as log6} from "@stacksjs/logging";
 import {createFolder, doesFolderExist, writeTextFile} from "@stacksjs/storage";
 import {frameworkPath as frameworkPath2, projectPath as projectPath3, resolve} from "@stacksjs/path";
@@ -282,7 +274,7 @@ async function makeComponent(options) {
     const name = options.name;
     log6.info("Creating your component...");
     await createComponent(options);
-    log6.success(`Created ${italic2(name)} component`);
+    log6.success(`Created ${italic(name)} component`);
   } catch (error) {
     log6.error("There was an error creating your component", error);
     process3.exit();
@@ -308,9 +300,9 @@ console.log('Hello World component created')
 function makeDatabase(options) {
   try {
     const name = options.name;
-    log6.info(`Creating your ${italic2(name)} database...`);
+    log6.info(`Creating your ${italic(name)} database...`);
     createDatabase(options);
-    log6.success(`Created ${italic2(name)} database`);
+    log6.success(`Created ${italic(name)} database`);
   } catch (error) {
     log6.error("There was an error creating your database", error);
     process3.exit();
@@ -322,9 +314,9 @@ function createDatabase(options) {
 function factory(options) {
   try {
     const name = options.name;
-    log6.info(`Creating your ${italic2(name)} factory...`);
+    log6.info(`Creating your ${italic(name)} factory...`);
     createDatabase(options);
-    log6.success(`Created ${italic2(name)} factory`);
+    log6.success(`Created ${italic(name)} factory`);
   } catch (error) {
     log6.error("There was an error creating your factory", error);
     process3.exit();
@@ -336,9 +328,9 @@ function createFactory(options) {
 async function makeNotification(options) {
   try {
     const name = options.name;
-    log6.info(`Creating your ${italic2(name)} notification...`);
+    log6.info(`Creating your ${italic(name)} notification...`);
     await createNotification(options);
-    log6.success(`Created ${italic2(name)} notification`);
+    log6.success(`Created ${italic(name)} notification`);
   } catch (error) {
     log6.error("There was an error creating your notification", error);
     process3.exit();
@@ -526,12 +518,18 @@ export default <Model> {
 class Action3 {
   name;
   description;
-  longRunning;
+  rate;
+  tries;
+  backoff;
+  enabled;
   handle;
-  constructor({ name, description, handle }) {
+  constructor({ name, description, handle, rate, tries, backoff, enabled }) {
     this.name = name;
     this.description = description;
-    this.longRunning = false;
+    this.rate = rate;
+    this.tries = tries;
+    this.backoff = backoff;
+    this.enabled = enabled;
     this.handle = handle;
   }
 }

package/dist/src/lint/fix.js

@@ -1,8 +1,9 @@
 // @bun
 // src/lint/fix.ts
-import {log, runCommands} from "@stacksjs/cli";
+import {log, parseOptions, runCommand} from "@stacksjs/cli";
 import {projectPath} from "@stacksjs/path";
 import {NpmScript} from "@stacksjs/enums";
 log.info("Ensuring Code Style...");
-await runCommands([NpmScript.LintFix], { cwd: projectPath() });
+var options = parseOptions();
+await runCommand(NpmScript.LintFix, { cwd: projectPath() }, options);
 log.success("Linted");

package/dist/src/release.js

@@ -3,48 +3,40 @@
 
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))
@@ -256,7 +248,7 @@ async function installPackages(names) {
 
 // src/make.ts
 import process3 from "process";
-import {italic as italic2} from "@stacksjs/cli";
+import {italic} from "@stacksjs/cli";
 import {log as log6} from "@stacksjs/logging";
 import {createFolder, doesFolderExist, writeTextFile} from "@stacksjs/storage";
 import {frameworkPath as frameworkPath2, projectPath as projectPath3, resolve} from "@stacksjs/path";
@@ -284,7 +276,7 @@ async function makeComponent(options) {
     const name = options.name;
     log6.info("Creating your component...");
     await createComponent(options);
-    log6.success(`Created ${italic2(name)} component`);
+    log6.success(`Created ${italic(name)} component`);
   } catch (error) {
     log6.error("There was an error creating your component", error);
     process3.exit();
@@ -310,9 +302,9 @@ console.log('Hello World component created')
 function makeDatabase(options) {
   try {
     const name = options.name;
-    log6.info(`Creating your ${italic2(name)} database...`);
+    log6.info(`Creating your ${italic(name)} database...`);
     createDatabase(options);
-    log6.success(`Created ${italic2(name)} database`);
+    log6.success(`Created ${italic(name)} database`);
   } catch (error) {
     log6.error("There was an error creating your database", error);
     process3.exit();
@@ -324,9 +316,9 @@ function createDatabase(options) {
 function factory(options) {
   try {
     const name = options.name;
-    log6.info(`Creating your ${italic2(name)} factory...`);
+    log6.info(`Creating your ${italic(name)} factory...`);
     createDatabase(options);
-    log6.success(`Created ${italic2(name)} factory`);
+    log6.success(`Created ${italic(name)} factory`);
   } catch (error) {
     log6.error("There was an error creating your factory", error);
     process3.exit();
@@ -338,9 +330,9 @@ function createFactory(options) {
 async function makeNotification(options) {
   try {
     const name = options.name;
-    log6.info(`Creating your ${italic2(name)} notification...`);
+    log6.info(`Creating your ${italic(name)} notification...`);
     await createNotification(options);
-    log6.success(`Created ${italic2(name)} notification`);
+    log6.success(`Created ${italic(name)} notification`);
   } catch (error) {
     log6.error("There was an error creating your notification", error);
     process3.exit();
@@ -528,12 +520,18 @@ export default <Model> {
 class Action3 {
   name;
   description;
-  longRunning;
+  rate;
+  tries;
+  backoff;
+  enabled;
   handle;
-  constructor({ name, description, handle }) {
+  constructor({ name, description, handle, rate, tries, backoff, enabled }) {
     this.name = name;
     this.description = description;
-    this.longRunning = false;
+    this.rate = rate;
+    this.tries = tries;
+    this.backoff = backoff;
+    this.enabled = enabled;
     this.handle = handle;
   }
 }
@@ -546,5 +544,8 @@ await runActions([
   Action4.GenerateLibraryEntries,
   Action4.LintFix,
   Action4.Bump
-], { cwd: projectPath4(), stdin: "inherit" });
+], {
+  cwd: projectPath4(),
+  stdin: "inherit"
+});
 log7.success(`Successfully released ${app.name}`);

package/dist/src/upgrade/index.js

@@ -1,48 +1,40 @@
 // @bun
 // src/helpers/utils.ts
 import * as storage from "@stacksjs/storage";
-import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import * as p from "@stacksjs/path";
 import {err, handleError} from "@stacksjs/error-handling";
-var parseOptions = function(options) {
-  if (!options)
-    return "";
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`;
-    if (typeof value === "boolean" && value)
-      return `--${key}`;
-    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
-  });
-  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
-};
 async function runAction(action, options) {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`));
-  const opts = parseOptions(options);
+  const opts = buddyOptions();
   const path = p.relativeActionsPath(`${action}.ts`);
-  const cmd = `bun --bun ${`${path} ${opts}`}`;
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options
   };
-  if (options?.verbose) {
-    log.debug("Running cmd:", underline(italic(cmd)));
-    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
-    log.debug("with action options of:", o);
-  }
-  return await runCommand(cmd, o);
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  return await runCommand(cmd, optionsWithCwd);
 }
 async function runActions(actions, options) {
+  log.debug("runActions:", actions);
+  log.debug("actions options:", options);
   if (!actions.length)
     return err("No actions were specified");
   for (const action of actions) {
     if (!hasAction(action))
       return err(`The specified action "${action}" does not exist`);
   }
-  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
-  return await runCommands(commands, options);
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
 }
 function hasAction(action) {
   if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))

package/dist/src/upgrade.js

@@ -6,7 +6,7 @@ import {log} from "@stacksjs/logging";
 import {projectPath} from "@stacksjs/path";
 import * as storage from "@stacksjs/storage";
 // package.json
-var version = "0.58.57";
+var version = "0.58.59";
 
 // src/upgrade.ts
 function checkForUncommittedChanges(options2) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/actions",
   "type": "module",
-  "version": "0.58.57",
+  "version": "0.58.59",
   "description": "The Stacks actions.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/action.ts

@@ -1,13 +1,21 @@
+import type { JobOptions } from '@stacksjs/types'
+
 export class Action {
   name: string
   description: string
-  longRunning: boolean
+  rate: JobOptions['rate']
+  tries: JobOptions['tries']
+  backoff: JobOptions['backoff']
+  enabled: JobOptions['enabled']
   handle: () => Promise<string>
 
-  constructor({ name, description, handle }: { name: string, description: string, handle: () => Promise<string> }) {
+  constructor({ name, description, handle, rate, tries, backoff, enabled }: { name: string, description: string, handle: () => Promise<string>, rate: JobOptions['rate'], tries: JobOptions['tries'], backoff: JobOptions['backoff'], enabled: JobOptions['enabled'] }) {
     this.name = name
     this.description = description
-    this.longRunning = false // TODO: Implement long running actions
+    this.rate = rate
+    this.tries = tries
+    this.backoff = backoff
+    this.enabled = enabled
     this.handle = handle
   }
 }

package/src/bump.ts

@@ -1,11 +1,18 @@
-import { runCommand } from '@stacksjs/cli'
+import { parseOptions, runCommand } from '@stacksjs/cli'
 import { path as p } from '@stacksjs/path'
 
-await runCommand('buddy changelog --quiet', {
+const options = parseOptions()
+const changelogCommand = options?.dryRun ? 'buddy changelog --quiet --dry-run' : 'buddy changelog --quiet'
+
+await runCommand(changelogCommand, {
   cwd: p.projectPath(),
 })
 
-await runCommand(
-  'bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all',
-  { cwd: p.frameworkPath(), stdin: 'inherit' },
-)
+const bumpCommand = options?.dryRun
+  ? 'bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --no-push'
+  : 'bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all'
+
+await runCommand(bumpCommand, {
+  cwd: p.frameworkPath(),
+  stdin: 'inherit',
+})

package/src/changelog.ts

@@ -1,11 +1,21 @@
-import { execSync, runCommand } from '@stacksjs/cli'
+import { execSync, log, parseOptions, runCommand } from '@stacksjs/cli'
 import { projectPath } from '@stacksjs/path'
 
+// when log.debug is used, only log to file in production
+log.debug('Generating changelog')
 const fromRevision = await execSync('git describe --abbrev=0 --tags HEAD^')
-// console.log('fromRevision', fromRevision)
+log.debug('FromRevision', fromRevision)
 const toRevision = await execSync('git describe')
-// console.log('toRevision', toRevision)
+log.debug('ToRevision', toRevision)
+const options = parseOptions()
+log.debug('Changelog Options', options)
 
-await runCommand(`bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`, {
+const command = options?.dryRun
+  ? `bunx changelogen --no-output --from ${fromRevision} --to ${toRevision}`
+  : `bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`
+
+await runCommand(command, {
   cwd: projectPath(),
+  quiet: options?.quiet,
+  verbose: options?.verbose,
 })

package/src/helpers/utils.ts

@@ -1,29 +1,10 @@
 import * as storage from '@stacksjs/storage'
-import { italic, runCommand, runCommands, underline } from '@stacksjs/cli'
+import { buddyOptions, runCommand, runCommands } from '@stacksjs/cli'
 import { log } from '@stacksjs/logging'
 import * as p from '@stacksjs/path'
 import type { ActionOptions, StacksError, Subprocess } from '@stacksjs/types'
-import { type Result, err, handleError } from '@stacksjs/error-handling'
-
-function parseOptions(options?: ActionOptions) {
-  if (!options)
-    return ''
-
-  const parsedOptions = Object.entries(options).map(([key, value]) => {
-    if (key.length === 1)
-      return `-${key}=${value}`
-
-    if (typeof value === 'boolean' && value) // if the value is `true`, just return the key
-      return `--${key}`
-
-    return `--${key}=${typeof value === 'string' && value.includes(' ') ? `"${value}"` : value}`
-  })
-
-  // filter out undefined values and join the array
-  return parsedOptions.filter(Boolean).join(' ').replace('----=', '')
-}
-
-// export type ActionResult = CommandResult
+import type { Result } from '@stacksjs/error-handling'
+import { err, handleError } from '@stacksjs/error-handling'
 
 /**
  * Run an Action the Stacks way.
@@ -33,24 +14,21 @@ function parseOptions(options?: ActionOptions) {
  * @returns The result of the command.
  */
 export async function runAction(action: string, options?: ActionOptions): Promise<Result<Subprocess, StacksError>> {
-  if (!hasAction(action))
-    return err(handleError(`The specified action "${action}" does not exist`))
-
-  const opts = parseOptions(options)
+  const opts = buddyOptions()
   const path = p.relativeActionsPath(`${action}.ts`)
-  const cmd = `bun --bun ${`${path} ${opts}`}`
-  const o = {
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd()
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options,
   }
 
-  if (options?.verbose) {
-    log.debug('Running cmd:', underline(italic(cmd)))
-    log.debug('Running action:', underline(italic(`./actions/${action}.ts`)))
-    log.debug('with action options of:', o)
-  }
+  log.debug('runAction:', cmd)
+  log.debug('action options:', optionsWithCwd)
+
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`))
 
-  return await runCommand(cmd, o)
+  return await runCommand(cmd, optionsWithCwd)
 }
 
 /**
@@ -61,6 +39,9 @@ export async function runAction(action: string, options?: ActionOptions): Promis
  * @returns The result of the command.
  */
 export async function runActions(actions: string[], options?: ActionOptions) {
+  log.debug('runActions:', actions)
+  log.debug('actions options:', options)
+
   if (!actions.length)
     return err('No actions were specified')
 
@@ -69,9 +50,16 @@ export async function runActions(actions: string[], options?: ActionOptions) {
       return err(`The specified action "${action}" does not exist`)
   }
 
-  const commands = actions.map(action => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`)
+  const opts = buddyOptions()
+
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options,
+  }
+
+  const commands = actions.map(action => `bun --bun ${p.relativeActionsPath(`${action}.ts`)} ${opts}`)
 
-  return await runCommands(commands, options)
+  return await runCommands(commands, o)
 }
 
 export function hasAction(action: string) {

package/src/lint/fix.ts

@@ -1,7 +1,8 @@
-import { log, runCommands } from '@stacksjs/cli'
+import { log, parseOptions, runCommand } from '@stacksjs/cli'
 import { projectPath } from '@stacksjs/path'
 import { NpmScript } from '@stacksjs/enums'
 
 log.info('Ensuring Code Style...')
-await runCommands([NpmScript.LintFix], { cwd: projectPath() })
+const options = parseOptions()
+await runCommand(NpmScript.LintFix, { cwd: projectPath() }, options)
 log.success('Linted')

package/src/release.ts

@@ -10,6 +10,9 @@ await runActions([
   Action.LintFix, // ensure there are no lint errors
   // Action.Test, // run the tests
   Action.Bump, // bump the versions, create the git tag, generate the changelog, commit & push the changes
-], { cwd: projectPath(), stdin: 'inherit' }) // debug mode needs to be enabled to see the output due to the interactive prompts
+], { // debug mode needs to be enabled to see the output due to the interactive prompts
+  cwd: projectPath(),
+  stdin: 'inherit',
+})
 
 log.success(`Successfully released ${app.name}`)