@stacksjs/actions 0.58.58 → 0.58.61

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/clean.js

@@ -1,6 +1,6 @@
 // @bun
 // src/clean.ts
 import {log} from "@stacksjs/logging";
-import {clean} from "@stacksjs/utils";
+import {cleanProject} from "@stacksjs/utils";
 log.info("Running clean command...");
-await clean();
+await cleanProject();

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();

package/dist/src/lint/fix.js

@@ -1,8 +1,12 @@
 // @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();
@@ -552,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

@@ -5,33 +5,36 @@ import {intro, outro, runCommand} from "@stacksjs/cli";
 import {log} from "@stacksjs/logging";
 import {projectPath} from "@stacksjs/path";
 import * as storage from "@stacksjs/storage";
+import {NpmScript} from "@stacksjs/enums";
 // package.json
-var version = "0.58.58";
+var version = "0.58.61";
 
 // src/upgrade.ts
-function checkForUncommittedChanges(options2) {
+function checkForUncommittedChanges(options) {
   try {
   } catch (error) {
     if (error.status === 1) {
-      if (!options2?.force) {
+      if (!options?.force) {
       }
     }
   }
 }
-async function downloadFrameworkUpdate(options2) {
+async function downloadFrameworkUpdate(options) {
   const tempFolderName = "updates";
   const tempUpdatePath = projectPath(tempFolderName);
   if (storage.doesFolderExist(tempUpdatePath))
     await deleteFolder(tempUpdatePath);
   log.info("Downloading framework updates...");
-  await runCommand(`giget stacks ${tempFolderName}`, options2);
+  await runCommand(`giget stacks ${tempFolderName}`, options);
   log.success(`Your framework updated correctly to version: v${version}`);
 }
 async function updateDependencies() {
   const perf = await intro("buddy upgrade:dependencies");
-  const result = await runCommand(NpmScript.UpgradeDependencies, options);
+  const result = await runCommand(NpmScript.UpgradeDependencies, {
+    cwd: projectPath()
+  });
   if (result.isErr()) {
-    outro("While running the upgrade:dependencies command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+    await outro("While running the upgrade:dependencies command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
     process.exit();
   }
   await outro("Freshly updated your dependencies.", { startTime: perf, useSeconds: true });

package/package.json

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

package/src/action.ts

@@ -1,15 +1,25 @@
 import type { JobOptions } from '@stacksjs/types'
 
+interface ActionOptions {
+  name?: string
+  description?: string
+  handle: () => Promise<any> | any
+  rate?: JobOptions['rate']
+  tries?: JobOptions['tries']
+  backoff?: JobOptions['backoff']
+  enabled?: JobOptions['enabled']
+}
+
 export class Action {
-  name: string
-  description: string
-  rate: JobOptions['rate']
-  tries: JobOptions['tries']
-  backoff: JobOptions['backoff']
-  enabled: JobOptions['enabled']
-  handle: () => Promise<string>
+  name?: string
+  description?: string
+  rate?: JobOptions['rate']
+  tries?: JobOptions['tries']
+  backoff?: JobOptions['backoff']
+  enabled?: JobOptions['enabled']
+  handle: () => Promise<any>
 
-  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'] }) {
+  constructor({ name, description, handle, rate, tries, backoff, enabled }: ActionOptions) {
     this.name = name
     this.description = description
     this.rate = rate

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/clean.ts

@@ -1,6 +1,6 @@
 import { log } from '@stacksjs/logging'
-import { clean } from '@stacksjs/utils'
+import { cleanProject } from '@stacksjs/utils'
 
 log.info('Running clean command...')
 
-await clean()
+await cleanProject()

package/src/dev/api.ts

@@ -5,8 +5,7 @@ import { config } from '@stacksjs/config'
 
 const options = parseOptions()
 
-if (options.verbose)
-  log.info('Running API dev server via', `bunx vite --config ${p.vitePath('src/api.ts')}`, options)
+log.debug('Running API dev server via', `bunx vite --config ${p.vitePath('src/api.ts')}`, options)
 
 serve({
   port: config.app.ports?.api, // defaults to 3999

package/src/domains/add.ts

@@ -1,34 +1,20 @@
 import process from 'node:process'
 import { createHostedZone, getNameservers, updateNameservers } from '@stacksjs/dns'
 import { app } from '@stacksjs/config'
-import { handleError } from '@stacksjs/error-handling'
-import { italic, parseOptions, runCommand } from '@stacksjs/cli'
+import { italic, log, parseOptions, runCommand } from '@stacksjs/cli'
 import { whois } from '@stacksjs/whois'
 import { logger } from '@stacksjs/logging'
 import { projectConfigPath } from '@stacksjs/path'
 
-interface AddOptions {
-  domain?: string
-  verbose: boolean
-}
-
-const parsedOptions = parseOptions()
-const options: AddOptions = {
-  domain: parsedOptions.domain as string,
-  verbose: parsedOptions.verbose as boolean,
-}
+const options = parseOptions()
+const domain = (options.domain as string | undefined) ?? app.url
 
-if (!options.domain) {
-  if (app.url) {
-    options.domain = app.url
-  }
-  else {
-    handleError('there was no domain provided when')
-    process.exit(1)
-  }
+if (!domain) {
+  log.error('There was no Domain or App URL provided. Please provide a domain using the --domain flag or add a url to your app config.')
+  process.exit(1)
 }
 
-const result = await createHostedZone(options.domain)
+const result = await createHostedZone(domain)
 
 if (result.isErr()) {
   handleError(result.error)
@@ -36,22 +22,21 @@ if (result.isErr()) {
 }
 
 // Update the nameservers
-const nameServers = await getNameservers(options.domain)
+const nameServers = await getNameservers(domain)
 
 if (!nameServers) {
-  handleError(`No nameservers found for domain: ${options.domain}. Please ensure the Hosted Zone exists in Route53.`)
+  handleError(`No nameservers found for domain: ${domain}. Please ensure the Hosted Zone exists in Route53.`)
   process.exit(1)
 }
 
 await updateNameservers(nameServers)
 
-const nameservers = result.value
-const registrar: string = (await whois(options.domain, true)).parsedData.Registrar
+const registrar: string = (await whois(domain, true)).parsedData.Registrar
 
 // usually for Route53 registered domains, we don't need to update create a hosted zone as it's already
 // done for us. But in case it's not, we still need to ensure it's created before we can deploy
 if (registrar.includes('Amazon')) {
-  if (parsedOptions.deploy) {
+  if (options.deploy) {
     await runCommand('buddy deploy')
   }
   else {
@@ -70,7 +55,7 @@ logger.log(`   update your ${registrar} nameservers to the following:`)
 
 const emojis = ['1️⃣', '2️⃣', '3️⃣', '4️⃣']
 logger.log('')
-nameservers.forEach((nameserver, index) => {
+nameServers.forEach((nameserver: string, index: number) => {
   logger.log(`  ${emojis[index]}  Nameserver: ${nameserver}`)
 })
 logger.log('')

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,13 @@
-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/migrate/dns.ts

@@ -1,3 +1,3 @@
-import { generateMigrations } from './generate'
+import { generateMigrations } from '../generate'
 
 generateMigrations()

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}`)

package/src/upgrade.ts

@@ -3,6 +3,7 @@ import { intro, outro, runCommand } from '@stacksjs/cli'
 import { log } from '@stacksjs/logging'
 import { projectPath } from '@stacksjs/path'
 import * as storage from '@stacksjs/storage'
+import { NpmScript } from '@stacksjs/enums'
 import type { UpgradeOptions } from '@stacksjs/types'
 import { version } from '../package.json'
 
@@ -53,10 +54,12 @@ export async function downloadFrameworkUpdate(options: UpgradeOptions) {
 // export async function updateDependencies(options: UpgradeOptions) {
 export async function updateDependencies() {
   const perf = await intro('buddy upgrade:dependencies')
-  const result = await runCommand(NpmScript.UpgradeDependencies, options)
+  const result = await runCommand(NpmScript.UpgradeDependencies, {
+    cwd: projectPath(),
+  })
 
   if (result.isErr()) {
-    outro('While running the upgrade:dependencies command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+    await outro('While running the upgrade:dependencies command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
     process.exit()
   }