stacks 0.58.58 → 0.58.60

package/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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/core/actions/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}`);