@stacksjs/actions 0.70.87 → 0.70.90

package/dist/helpers/package-json.js

@@ -1,26 +1,47 @@
-// @bun
-import{Gb as q}from"../chunk-tsbk5vne.js";import"../chunk-h3d81wrg.js";import{log as G}from"@stacksjs/logging";import{packageJsonPath as I}from"@stacksjs/path";import{writeTextFile as K}from"@stacksjs/storage";async function R(v){let B,C,z,D,E,A;if(v==="web-components")B=q.webComponents?.name,C=q.webComponents?.description,z="components",D=q.webComponents?.keywords,E="web-components";else if(v==="functions")B=q.functions?.name,C=q.functions?.description,z="functions",D=q.functions?.keywords,E="functions";try{if(await K({path:I(v),data:`{
-  "name": "${B}",
+import { log } from "@stacksjs/logging";
+import { packageJsonPath } from "@stacksjs/path";
+import { writeTextFile } from "@stacksjs/storage";
+import library from "~/config/library";
+export async function generatePackageJson(type) {
+  let name, description, directory, keywords, config, prettyName;
+  if (type === "web-components") {
+    name = library.webComponents?.name;
+    description = library.webComponents?.description;
+    directory = "components";
+    keywords = library.webComponents?.keywords;
+    config = "web-components";
+  } else if (type === "functions") {
+    name = library.functions?.name;
+    description = library.functions?.description;
+    directory = "functions";
+    keywords = library.functions?.keywords;
+    config = "functions";
+  }
+  try {
+    await writeTextFile({
+      path: packageJsonPath(type),
+      data: `{
+  "name": "${name}",
   "type": "module",
   "version": "",
   "packageManager": "bun",
-  "description": "${C}",
-  "author": "${q.author}",
+  "description": "${description}",
+  "author": "${library.author}",
   "license": "MIT",
-  "homepage": "https://github.com/${q.repository}/tree/main/${z}#readme",
+  "homepage": "https://github.com/${library.repository}/tree/main/${directory}#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/${q.repository}.git",
-    "directory": "${z}"
+    "url": "git+https://github.com/${library.repository}.git",
+    "directory": "${directory}"
   },
   "bugs": {
-    "url": "https://github.com/${q.repository}/issues"
+    "url": "https://github.com/${library.repository}/issues"
   },
-  "keywords": ${JSON.stringify(D)},
-  "contributors": ${JSON.stringify(q.contributors)},
+  "keywords": ${JSON.stringify(keywords)},
+  "contributors": ${JSON.stringify(library.contributors)},
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/index.d.js",
       "require": "./dist/index.cjs",
       "import": "./dist/index.js"
     }
@@ -33,11 +54,21 @@ import{Gb as q}from"../chunk-tsbk5vne.js";import"../chunk-h3d81wrg.js";import{lo
     "README.md"
   ],
   "scripts": {
-    "build": "vite build -c ../build/${E}.ts",
+    "build": "vite build -c ../build/${config}.ts",
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
     "stacks": "workspace:*"
   }
 }
-`}),v==="web-components")A="Web Component library";else if(v==="functions")A="Function Library";G.success(`Created ${A} package.json file`)}catch(H){G.error(`There was an error creating the ${A} package.json`,H)}}export{R as generatePackageJson};
+`
+    });
+    if (type === "web-components")
+      prettyName = "Web Component library";
+    else if (type === "functions")
+      prettyName = "Function Library";
+    log.success(`Created ${prettyName} package.json file`);
+  } catch (err) {
+    log.error(`There was an error creating the ${prettyName} package.json`, err);
+  }
+}

package/dist/helpers/utils.js

@@ -1,2 +1,105 @@
-// @bun
-import{Ib as a,Jb as b,Kb as c}from"../chunk-0gadhvn7.js";import"../chunk-h3d81wrg.js";export{b as runActions,a as runAction,c as hasAction};
+var {require}=import.meta;import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { buddyOptions, runCommand, runCommands } from "@stacksjs/cli";
+import { err } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+async function resolveActionFile(action) {
+  const candidates = [];
+  candidates.push(p.actionsPath(`src/${action}.ts`));
+  try {
+    const pkgUrl = import.meta.resolve("@stacksjs/actions/package.json");
+    if (pkgUrl) {
+      const pkgPath = new URL(pkgUrl).pathname, pkgRoot = pkgPath.slice(0, pkgPath.lastIndexOf("/"));
+      candidates.push(`${pkgRoot}/dist/${action}.js`);
+      candidates.push(`${pkgRoot}/dist/src/${action}.js`);
+      candidates.push(`${pkgRoot}/src/${action}.ts`);
+    }
+  } catch {}
+  for (const candidate of candidates)
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  return null;
+}
+export async function runAction(action, options) {
+  log.debug(`[action] Running: ${action}`);
+  if (action === "dev/views")
+    try {
+      const pantryPath = p.projectPath("pantry");
+      if (!process.env.NODE_PATH?.includes(pantryPath)) {
+        process.env.NODE_PATH = process.env.NODE_PATH ? `${pantryPath}:${process.env.NODE_PATH}` : pantryPath;
+        require("module").Module._initPaths?.();
+      }
+      const viewsEntries = [
+        p.projectPath("storage/framework/core/actions/src/dev/views.ts"),
+        p.frameworkPath("actions/src/dev/views.ts")
+      ];
+      for (const entry of viewsEntries)
+        if (existsSync(entry)) {
+          await import(entry);
+          return { ok: !0, value: {} };
+        }
+      return err("dev/views entry not found");
+    } catch (error) {
+      return err(`Failed to start dev server: ${error}`);
+    }
+  if (!(action.includes("/") || ["dev", "build", "install", "upgrade", "migrate"].some((prefix) => action.startsWith(prefix)))) {
+    const glob = new Bun.Glob("**/*.{ts,js}"), scanOptions = { cwd: p.userActionsPath(), onlyFiles: !0, absolute: !0 }, matchingFiles = [], basePath = p.userActionsPath();
+    for await (const file of glob.scan(scanOptions)) {
+      if (file.replace(`${basePath}/`, "").replace(/\.(ts|js)$/, "") === action || file.endsWith(`${action}.ts`) || file.endsWith(`${action}.js`)) {
+        log.debug(`[action] Resolved: ${action} \u2192 ${file}`);
+        return await (await import(file)).default.handle(void 0);
+      }
+      matchingFiles.push(file);
+    }
+    for (const file of matchingFiles)
+      try {
+        const a = await import(file);
+        if (a.name === action) {
+          log.debug(`[action] Resolved: ${action} \u2192 ${file}`);
+          return await a.handle();
+        }
+      } catch (error) {}
+  }
+  const path = await resolveActionFile(action);
+  if (!path)
+    return err(`Action '${action}' not found in storage/framework/core/actions/src or @stacksjs/actions`);
+  log.debug(`[action] Resolved: ${action} \u2192 ${path}`);
+  const isDevAction = action.startsWith("dev/"), watchFlag = isDevAction ? "--watch" : "", opts = isDevAction ? "" : buddyOptions(options) || "", cmd = `bun ${watchFlag} ${path} ${opts}`.trimEnd(), pantryNodePath = p.projectPath("pantry"), existingNodePath = process.env.NODE_PATH, nodePath = existingNodePath ? `${pantryNodePath}:${existingNodePath}` : pantryNodePath, shouldInherit = options?.verbose || isDevAction && !options?.quiet, optionsWithCwd = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options,
+    stdout: shouldInherit ? "inherit" : void 0,
+    stderr: shouldInherit ? "inherit" : void 0,
+    env: { ...options?.env, NODE_PATH: nodePath, ...isDevAction ? { STACKS_DEV_SERVER: "1" } : {} }
+  }, result = await runCommand(cmd, optionsWithCwd);
+  log.debug(`[action] Completed: ${action}`);
+  return result;
+}
+export async function runActions(actions, 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 opts = buddyOptions(options) || "", o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  }, commands = actions.map((action) => `bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
+}
+export function hasAction(action) {
+  const userActionPatterns = [
+    `${action}.ts`,
+    `${action}`,
+    `Dashboard/${action}.ts`,
+    `Dashboard/${action}`,
+    `Buddy/${action}.ts`,
+    `Buddy/${action}`
+  ], actionPatterns = [`src/${action}.ts`, `src/${action}`, `${action}.ts`, `${action}`];
+  return [
+    ...userActionPatterns.map((pattern) => p.userActionsPath(pattern)),
+    ...actionPatterns.map((pattern) => p.actionsPath(pattern))
+  ].some((candidate) => existsSync(candidate));
+}

package/dist/helpers/vscode-custom-data.js

@@ -1,2 +1,30 @@
-// @bun
-import{Eb as a,Fb as b}from"../chunk-tpb8jgsk.js";import"../chunk-tsbk5vne.js";import"../chunk-h3d81wrg.js";export{b as generateWebTypes,a as generateVsCodeCustomData};
+import { err, ok } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import { customElementsDataPath } from "@stacksjs/path";
+import { writeTextFile } from "@stacksjs/storage";
+import library from "~/config/library";
+function generateComponentInfoData() {
+  return `{
+  "version": 1.1,
+  "tags": ${JSON.stringify(library.webComponents?.tags)}
+}
+`;
+}
+export async function generateVsCodeCustomData() {
+  try {
+    log.info("Generating custom-elements.json...");
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+    log.success("Generated custom-elements.json for IDEs.");
+    return ok(void 0);
+  } catch (e) {
+    log.error("There was an error generating the custom-elements.json file.", e);
+    return err("There was an error generating the custom-elements.json file.");
+  }
+}
+export async function generateWebTypes() {
+  log.info("Generating web-types.json...");
+  log.info("This feature is not yet implemented.");
+}

package/dist/index.d.ts

@@ -2,6 +2,19 @@ export type { CrudField } from './scaffold-crud';
 export type { DiscoveredPackagesManifest, PackageStacksMeta } from './discover-packages';
 export * from './action';
 export { add as runAdd } from './add';
+// The write side of the markdown blog (content/blog/*.md), used by the
+// dashboard's blog actions. The read/render side lives in ./blog and stays out
+// of this barrel because it lazy-loads BunPress.
+export {
+  type BlogPost,
+  BlogAdminError,
+  type BlogPostInput,
+  deleteBlogPost,
+  getBlogPost,
+  listBlogPosts,
+  saveBlogPost,
+  slugify as blogSlugify,
+} from './blog-admin';
 export { commit as runCommit } from './commit';
 export * from './dev/index';
 export * from './generate/index';

package/dist/index.js

@@ -1,2 +1,50 @@
-// @bun
-import{$ as Q,Aa as pa,Ba as qa,Ca as ra,Da as sa,Ea as ta,T as I,U as J,V as K,W as L,X as M,Y as N,Z as O,_ as P,aa as R,ba as S,ca as T,da as U,ea as V,fa as W,ga as X,ha as Y,ia as Z,ja as _,ka as $,la as aa,ma as ba,na as ca,oa as da,pa as ea,qa as fa,ra as ga,sa as ha,ta as ia,ua as ja,va as ka,wa as la,xa as ma,ya as na,za as oa}from"./chunk-0c8sd1t6.js";import"./chunk-cdk2r2jd.js";import{Fa as A,Ga as B,Ha as C,Ia as D,Ja as E,Ka as F,La as G,Ma as H}from"./chunk-n5eqwhck.js";import{ib as r,jb as s,kb as t,lb as u,mb as v,nb as w,ob as x,pb as y,qb as z}from"./chunk-62gdfav8.js";import{Ab as n,Bb as o,Cb as p,Db as q,rb as e,sb as f,tb as g,ub as h,vb as i,wb as j,xb as k,yb as l,zb as m}from"./chunk-78c5n3s2.js";import"./chunk-tpb8jgsk.js";import"./chunk-tsbk5vne.js";import"./chunk-s735m9mg.js";import{Hb as a}from"./chunk-6bk53y02.js";import{Ib as b,Jb as c,Kb as d}from"./chunk-0gadhvn7.js";import"./chunk-h3d81wrg.js";export{m as watchTypes,oa as uninstallStack,E as trustCertificate,C as sslCertificatesExist,G as setupSSL,ja as setDryRun,ma as scaffoldCrud,x as runSystemTrayDevServer,ia as runMake,s as runFrontendDevServer,z as runDocsDevServer,r as runDevServer,y as runDesktopDevServer,w as runDashboardDevServer,v as runComponentsDevServer,J as runCommit,t as runBackendDevServer,u as runApiDevServer,I as runAdd,c as runActions,b as runAction,la as parseFields,ha as makeStack,ta as makeResource,ga as makeQueueTable,sa as makePolicy,fa as makePage,ea as makeNotification,da as makeMail,ca as makeLanguage,qa as makeJob,ba as makeFunction,aa as makeDatabase,$ as makeComponent,ra as makeCommand,_ as makeCertificate,Z as makeAction,pa as listStacks,M as lintProject,L as lintFix,H as isSSLSetupComplete,Y as isDryRunActive,A as isDomainInHosts,D as isCertificateTrusted,e as invoke,na as installStack,d as hasAction,h as generateWebTypes,i as generateVsCodeCustomData,l as generateTypes,o as generateSeeder,n as generatePantryConfig,q as generateOpenApiSpec,g as generateLibEntries,j as generateIdeHelpers,p as generateCoreSymlink,k as generateComponentMeta,F as generateCertificates,f as generate,K as formatProject,ka as discoverPackages,X as createPage,W as createNotification,U as createModel,T as createMigration,S as createMiddleware,V as createMail,R as createLanguage,Q as createFunction,P as createFactory,O as createDatabase,N as createComponent,B as addDomainToHosts,a as Action};
+export * from "./action";
+export { add as runAdd } from "./add";
+export {
+  BlogAdminError,
+  deleteBlogPost,
+  getBlogPost,
+  listBlogPosts,
+  saveBlogPost,
+  slugify as blogSlugify
+} from "./blog-admin";
+export { commit as runCommit } from "./commit";
+export * from "./dev";
+export * from "./generate";
+export * from "./helpers";
+export { formatProject, lintFix, lintProject } from "./lint/lint";
+export * from "./setup";
+export {
+  createComponent,
+  createDatabase,
+  createFactory,
+  createFunction,
+  createLanguage,
+  createMiddleware,
+  createMigration,
+  createModel,
+  createMail,
+  createNotification,
+  createPage,
+  isDryRunActive,
+  makeAction,
+  makeCertificate,
+  makeComponent,
+  makeDatabase,
+  makeFunction,
+  makeLanguage,
+  makeMail,
+  makeNotification,
+  makePage,
+  makeQueueTable,
+  makeStack,
+  make as runMake,
+  setDryRun
+} from "./make";
+export { discoverPackages } from "./discover-packages";
+export { parseFields, scaffoldCrud } from "./scaffold-crud";
+export { installStack, uninstallStack, listStacks } from "./stacks";
+export { makeJob } from "./make-job";
+export { makeCommand } from "./make-command";
+export { makePolicy } from "./make-policy";
+export { makeResource } from "./make-resource";

package/dist/key-generate.js

@@ -1,2 +1,24 @@
-// @bun
-import{readFileSync as J}from"fs";import{runCommand as L}from"@stacksjs/cli";import{generateKeypair as M}from"@stacksjs/env";import{projectPath as D}from"@stacksjs/path";import{generateAppKey as N}from"@stacksjs/security";import{existsSync as O}from"@stacksjs/storage";import{setEnvValue as q}from"@stacksjs/utils";if(!O(".env"))await L("cp .env.example .env",{cwd:D()});await q("APP_KEY",N());var G=(()=>{try{return J(D(".env"),"utf-8")}catch{return""}})(),z=/^DOTENV_PUBLIC_KEY=.+$/m.test(G),B=/^DOTENV_PRIVATE_KEY=.+$/m.test(G);if(!z||!B){let{publicKey:H,privateKey:I}=M();if(!z)await q("DOTENV_PUBLIC_KEY",H);if(!B)await q("DOTENV_PRIVATE_KEY",I)}
+import { readFileSync } from "node:fs";
+import { runCommand } from "@stacksjs/cli";
+import { generateKeypair } from "@stacksjs/env";
+import { projectPath } from "@stacksjs/path";
+import { generateAppKey } from "@stacksjs/security";
+import { existsSync } from "@stacksjs/storage";
+import { setEnvValue } from "@stacksjs/utils";
+if (!existsSync(".env"))
+  await runCommand("cp .env.example .env", { cwd: projectPath() });
+await setEnvValue("APP_KEY", generateAppKey());
+const envText = (() => {
+  try {
+    return readFileSync(projectPath(".env"), "utf-8");
+  } catch {
+    return "";
+  }
+})(), hasPublic = /^DOTENV_PUBLIC_KEY=.+$/m.test(envText), hasPrivate = /^DOTENV_PRIVATE_KEY=.+$/m.test(envText);
+if (!hasPublic || !hasPrivate) {
+  const { publicKey, privateKey } = generateKeypair();
+  if (!hasPublic)
+    await setEnvValue("DOTENV_PUBLIC_KEY", publicKey);
+  if (!hasPrivate)
+    await setEnvValue("DOTENV_PRIVATE_KEY", privateKey);
+}

package/dist/lint/fix.js

@@ -1,3 +1,4 @@
-#!/usr/bin/env bun
-// @bun
-import{Oa as b}from"../chunk-e142dheq.js";import"../chunk-h3d81wrg.js";import g from"process";var{ok:j}=await b();g.exit(j?0:1);
+import process from "node:process";
+import { lintFix } from "./lint";
+const { ok } = await lintFix();
+process.exit(ok ? 0 : 1);

package/dist/lint/index.js

@@ -1,3 +1,4 @@
-#!/usr/bin/env bun
-// @bun
-import{Na as f}from"../chunk-e142dheq.js";import"../chunk-h3d81wrg.js";import g from"process";var{ok:q}=await f();g.exit(q?0:1);
+import process from "node:process";
+import { lintProject } from "./lint";
+const { ok } = await lintProject();
+process.exit(ok ? 0 : 1);

package/dist/lint/lint.js

@@ -1,2 +1,34 @@
-// @bun
-import{Na as a,Oa as b,Pa as c}from"../chunk-e142dheq.js";import"../chunk-h3d81wrg.js";export{a as lintProject,b as lintFix,c as formatProject};
+import process from "node:process";
+import { log } from "@stacksjs/cli";
+import { execSync } from "node:child_process";
+import { runFormat, runLint } from "pickier";
+const lintableFile = /\.(?:ts|js|json|md|yaml|yml)$/i, ignoredPath = /(?:^|\/)(?:node_modules|dist|pantry|storage\/framework\/cache|\.git|\.stx|\.stx-serve)(?:\/|$)/;
+function trackedFiles(cwd) {
+  try {
+    return execSync("git ls-files -z", { cwd, encoding: "utf8" }).split("\x00").filter((file) => lintableFile.test(file) && !ignoredPath.test(file));
+  } catch {
+    return [];
+  }
+}
+export async function lintProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  log.info(options.fix ? "Ensuring Code Style..." : "Checking Code Style...");
+  const files = trackedFiles(cwd);
+  if (!files.length) {
+    log.success("Linted");
+    return { ok: !0 };
+  }
+  const ok = await runLint(files, { maxWarnings: 9999, fix: options.fix }) === 0;
+  if (ok)
+    log.success("Linted");
+  return { ok };
+}
+export function lintFix(options = {}) {
+  return lintProject({ ...options, fix: !0 });
+}
+export async function formatProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd(), files = trackedFiles(cwd);
+  if (!files.length)
+    return { ok: !0 };
+  return { ok: await runFormat(files, { write: options.write, check: options.check }) === 0 };
+}

package/dist/make-command.js

@@ -1,45 +1,95 @@
-// @bun
-import"./chunk-h3d81wrg.js";import{log as B}from"@stacksjs/logging";import*as G from"@stacksjs/path";import{get as O,writeFile as H}from"@stacksjs/storage";async function V(y){let z=y.name;if(!z)return B.error("Command name is required"),!1;let q=S(z),A=Q(q,y),D=G.commandsPath(`${q}.ts`);try{if(await H(D,A),B.success(`Created command: ${D}`),y.register!==!1)await R(q,y.signature||I(z));return!0}catch(E){return B.error(`Failed to create command: ${E.message}`),!1}}function Q(y,z){let q=z.signature||I(y),A=z.description||`The ${q} command`;return`import type { CLI } from '@stacksjs/types'
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import { get, writeFile } from "@stacksjs/storage";
+export async function makeCommand(options) {
+  const name = options.name;
+  if (!name) {
+    log.error("Command name is required");
+    return !1;
+  }
+  const commandName = toPascalCase(name), content = generateCommandContent(commandName, options), filePath = p.commandsPath(`${commandName}.ts`);
+  try {
+    await writeFile(filePath, content);
+    log.success(`Created command: ${filePath}`);
+    if (options.register !== !1)
+      await registerCommand(commandName, options.signature || toKebabCase(name));
+    return !0;
+  } catch (error) {
+    log.error(`Failed to create command: ${error.message}`);
+    return !1;
+  }
+}
+function generateCommandContent(name, options) {
+  const signature = options.signature || toKebabCase(name), description = options.description || `The ${signature} command`;
+  return `import type { CLI } from '@stacksjs/types'
 import { log } from '@stacksjs/cli'
 
 /**
- * ${y} Command
+ * ${name} Command
  *
- * ${A}
+ * ${description}
  */
 
-interface ${y}Options {
+interface ${name}Options {
   verbose: boolean
   // Add your command options here
 }
 
 export default function (cli: CLI) {
   cli
-    .command('${q}', '${A}')
+    .command('${signature}', '${description}')
     .option('--verbose', 'Enable verbose output', { default: false })
     // Add more options here
     // .option('-n, --name <name>', 'Your name')
-    .action(async (options: ${y}Options) => {
+    .action(async (options: ${name}Options) => {
       try {
         if (options.verbose) {
-          log.info('Running ${q} command...')
+          log.info('Running ${signature} command...')
         }
 
         log.info('No command logic implemented yet. Update this command action to add behavior.')
 
-        log.success('${q} completed successfully!')
+        log.success('${signature} completed successfully!')
       }
       catch (error) {
-        log.error('${q} failed:', error)
+        log.error('${signature} failed:', error)
         throw error
       }
     })
 
   // Handle unknown subcommands
-  cli.on('${q}:*', () => {
+  cli.on('${signature}:*', () => {
     log.error('Invalid command: %s\\nSee --help for a list of available commands.', cli.args.join(' '))
   })
 }
-`}async function R(y,z){let q=G.appPath("Commands.ts");try{let A=await O(q),D=A.match(/export default \{([\s\S]*)\} satisfies/);if(D){let E=D[1]??"";if(E.includes(`'${z}'`)){B.info(`Command '${z}' already registered in Commands.ts`);return}let J=`  '${z}': '${y}',
-`,L=`${E.trimEnd()}
-${J}`;A=A.replace(/export default \{[\s\S]*\} satisfies/,`export default {${L}} satisfies`),await H(q,A),B.success(`Registered command '${z}' in Commands.ts`)}}catch(A){B.warn(`Could not register command in Commands.ts: ${A.message}`),B.info("You may need to manually add it to app/Commands.ts")}}function S(y){return y.replace(/[-_](.)/g,(z,q)=>q.toUpperCase()).replace(/^(.)/,(z,q)=>q.toUpperCase())}function I(y){return y.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[_\s]+/g,"-").toLowerCase()}export{V as makeCommand};
+`;
+}
+async function registerCommand(name, signature) {
+  const commandsPath = p.appPath("Commands.ts");
+  try {
+    let content = await get(commandsPath);
+    const exportMatch = content.match(/export default \{([\s\S]*)\} satisfies/);
+    if (exportMatch) {
+      const existingCommands = exportMatch[1] ?? "";
+      if (existingCommands.includes(`'${signature}'`)) {
+        log.info(`Command '${signature}' already registered in Commands.ts`);
+        return;
+      }
+      const newCommand = `  '${signature}': '${name}',
+`, updatedCommands = `${existingCommands.trimEnd()}
+${newCommand}`;
+      content = content.replace(/export default \{[\s\S]*\} satisfies/, `export default {${updatedCommands}} satisfies`);
+      await writeFile(commandsPath, content);
+      log.success(`Registered command '${signature}' in Commands.ts`);
+    }
+  } catch (error) {
+    log.warn(`Could not register command in Commands.ts: ${error.message}`);
+    log.info("You may need to manually add it to app/Commands.ts");
+  }
+}
+function toPascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}

package/dist/make-job.js

@@ -1,31 +1,51 @@
-// @bun
-import"./chunk-h3d81wrg.js";import{log as A}from"@stacksjs/logging";import*as H from"@stacksjs/path";import{writeFile as L}from"@stacksjs/storage";async function T(v){let x=v,y=v.name;if(!y)return A.error("Job name is required"),!1;let z=y.endsWith("Job")?y:`${y}Job`,I=x.class??!1?Q(z,x):M(z,x),E=H.userJobsPath(`${z}.ts`);try{return await L(E,I),A.success(`Created job: ${E}`),!0}catch(K){return A.error(`Failed to create job: ${K.message}`),!1}}function M(v,x){let y=x.queue??"default",z=x.tries??3,D=x.backoff??3;return`import { Job } from '@stacksjs/queue'
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import { writeFile } from "@stacksjs/storage";
+export async function makeJob(options) {
+  const jobOptions = options, name = options.name;
+  if (!name) {
+    log.error("Job name is required");
+    return !1;
+  }
+  const jobName = name.endsWith("Job") ? name : `${name}Job`, content = jobOptions.class ?? !1 ? generateClassBasedJob(jobName, jobOptions) : generateFunctionBasedJob(jobName, jobOptions), filePath = p.userJobsPath(`${jobName}.ts`);
+  try {
+    await writeFile(filePath, content);
+    log.success(`Created job: ${filePath}`);
+    return !0;
+  } catch (error) {
+    log.error(`Failed to create job: ${error.message}`);
+    return !1;
+  }
+}
+function generateFunctionBasedJob(name, options) {
+  const queue = options.queue ?? "default", tries = options.tries ?? 3, backoff = options.backoff ?? 3;
+  return `import { Job } from '@stacksjs/queue'
 
 export default new Job({
   /**
    * The job name (optional, defaults to filename)
    */
-  name: '${v}',
+  name: '${name}',
 
   /**
    * A description of what this job does (optional)
    */
-  description: '${v} job',
+  description: '${name} job',
 
   /**
    * The queue this job should be dispatched to
    */
-  queue: '${y}',
+  queue: '${queue}',
 
   /**
    * Number of times to retry if the job fails
    */
-  tries: ${z},
+  tries: ${tries},
 
   /**
    * Seconds to wait between retry attempts
    */
-  backoff: ${D},
+  backoff: ${backoff},
 
   /**
    * Cron expression for scheduled jobs (optional)
@@ -58,14 +78,18 @@ export default new Job({
     return { success: true }
   },
 })
-`}function Q(v,x){let y=x.queue??"default",z=x.tries??3;return`import { log } from '@stacksjs/logging'
+`;
+}
+function generateClassBasedJob(name, options) {
+  const queue = options.queue ?? "default", tries = options.tries ?? 3;
+  return `import { log } from '@stacksjs/logging'
 
 /**
- * ${v}
+ * ${name}
  *
  * Generated job class.
  */
-export default class ${v} {
+export default class ${name} {
   /**
    * Job configuration
    */
@@ -73,7 +97,7 @@ export default class ${v} {
     /**
      * The queue this job should be dispatched to
      */
-    queue: '${y}',
+    queue: '${queue}',
 
     /**
      * Cron expression for scheduled jobs (optional)
@@ -97,7 +121,7 @@ export default class ${v} {
     /**
      * Number of retry attempts
      */
-    retries: ${z},
+    retries: ${tries},
 
     /**
      * Delay between retries in seconds
@@ -111,19 +135,20 @@ export default class ${v} {
    */
   public static async handle(payload?: Record<string, unknown>): Promise<{ success: boolean }> {
     try {
-      log.info('${v}: Starting job execution')
+      log.info('${name}: Starting job execution')
 
       // Add your job logic here.
       console.log('Processing with payload:', payload)
 
-      log.info('${v}: Job completed successfully')
+      log.info('${name}: Job completed successfully')
 
       return { success: true }
     }
     catch (error) {
-      log.error('${v}: Job failed:', error)
+      log.error('${name}: Job failed:', error)
       throw error
     }
   }
 }
-`}export{T as makeJob};
+`;
+}