chore: wip

Author: chrisbbreuer

app/Actions/BuddyAction.ts

@@ -5,6 +5,7 @@ route.get('/api/', () => 'hello world 2') // stacksjs.org/api/
 route.get('/api/welcome', () => 'hello world 3') // stacksjs.org/api/welcome
 route.get('/api/welcome/', () => 'hello world 4') // stacksjs.org/api/welcome/
 route.get('/api/health', () => 'healthy')
+route.get('/api/buddy', 'BuddyAction')
 
 // route.group({ prefix: '/users' }, () => {
 //   route.before(async (params) => {

routes/api.ts

@@ -1,11 +1,16 @@
-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(),
 })
 
+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(
-  'bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all',
+  bumpCommand,
   { cwd: p.frameworkPath(), stdin: 'inherit' },
 )

storage/framework/core/actions/src/bump.ts

@@ -1,11 +1,11 @@
-import { execSync, runCommand } from '@stacksjs/cli'
+import { execSync, parseOptions, runCommand } from '@stacksjs/cli'
 import { projectPath } from '@stacksjs/path'
 
 const fromRevision = await execSync('git describe --abbrev=0 --tags HEAD^')
-// console.log('fromRevision', fromRevision)
 const toRevision = await execSync('git describe')
-// console.log('toRevision', toRevision)
+const options = parseOptions()
 
-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(),
 })

storage/framework/core/actions/src/changelog.ts

@@ -1,29 +1,10 @@
 import * as storage from '@stacksjs/storage'
-import { italic, runCommand, runCommands, underline } from '@stacksjs/cli'
+import { buddyOptions, italic, parseOptions, runCommand, runCommands, underline } 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.
@@ -36,21 +17,22 @@ export async function runAction(action: string, options?: ActionOptions): Promis
   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}`
+  const optionsWithCwd = {
     cwd: options?.cwd || p.projectPath(),
     ...options,
   }
 
   if (options?.verbose) {
+    log.debug('Action command:', cmd)
     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('With action options of:', optionsWithCwd)
   }
 
-  return await runCommand(cmd, o)
+  return await runCommand(cmd, optionsWithCwd)
 }
 
 /**
@@ -69,9 +51,17 @@ 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`)}`)
+  // TODO: need to solve this error
+  const opts = buddyOptions()
+
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...parseOptions(),
+  }
+
+  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) {

storage/framework/core/actions/src/helpers/utils.ts

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

storage/framework/core/actions/src/lint/fix.ts

@@ -9,13 +9,15 @@ export function changelog(buddy: CLI) {
   const descriptions = {
     changelog: 'Create a CHANGELOG.md file',
     quiet: 'Minimal output',
+    dryRun: 'Do not write the file, just output the changes',
     project: 'Target a specific project',
     verbose: 'Enable verbose output',
   }
 
   buddy
     .command('changelog', descriptions.changelog)
     .option('--quiet', descriptions.quiet, { default: false })
+    .option('-d, --dry-run', descriptions.dryRun, { default: false })
     .option('-p, --project', descriptions.project, { default: false })
     .option('--verbose', descriptions.verbose, { default: false })
     .action(async (options: FreshOptions) => {

storage/framework/core/buddy/src/commands/changelog.ts

@@ -8,15 +8,20 @@ import { runAction } from '@stacksjs/actions'
 const descriptions = {
   release: 'Release a new version of your libraries/packages',
   project: 'Target a specific project',
+  dryRun: 'Run the release without actually releasing',
   verbose: 'Enable verbose output',
 }
 
 export function release(buddy: CLI) {
   buddy
     .command('release', descriptions.release)
+    .option('--dry-run', descriptions.dryRun, { default: false })
     .option('-p, --project', descriptions.project, { default: false })
     .option('--verbose', descriptions.verbose, { default: false })
     .action(async (options: ReleaseOptions) => {
+      if (options.dryRun)
+        log.warn('Dry run enabled. No changes will be made.')
+
       const startTime = await intro('buddy release')
       const result = await runAction(Action.Release, { ...options, stdin: 'inherit' })
 
@@ -25,7 +30,7 @@ export function release(buddy: CLI) {
         process.exit(ExitCode.FatalError)
       }
 
-      await outro('Triggered your CI/CD release workflow', { startTime, useSeconds: true })
+      await outro('Triggered CI/CD Release Workflow', { startTime, useSeconds: true })
     })
 
   buddy.on('release:*', () => {

storage/framework/core/buddy/src/commands/release.ts

@@ -2,7 +2,7 @@
 import cac from 'cac'
 import { version } from '../package.json'
 
-interface ParsedArgv {
+export interface ParsedArgv {
   args: ReadonlyArray<string>
   options: {
     [k: string]: any
@@ -32,21 +32,3 @@ export function cli(name?: string | CliOptions, options?: CliOptions) {
 export function command(name: string, description: string, options?: CliOptions) {
   return cli(options).command(name, description)
 }
-
-export function parseArgs() {
-  return cli().parse().args
-}
-
-export function parseOptions(): ParsedArgv['options'] {
-  const options = cli().parse().options
-
-  // Iterate over the options and convert "true" and "false" strings to boolean
-  for (const key in options) {
-    if (options[key] === 'true')
-      options[key] = true
-    else if (options[key] === 'false')
-      options[key] = false
-  }
-
-  return options
-}

storage/framework/core/cli/src/cli.ts

@@ -86,16 +86,71 @@ export function parseArgv(argv?: string[]): ParsedArgv {
   return { args, options }
 }
 
-// export function parseOptions(argv?: string[]): { [k: string]: string | boolean | number } {
-//   if (argv === undefined)
-//     argv = process.argv.slice(2)
-
-//   return parseArgv(argv).options
-// }
-
 export function parseArgs(argv?: string[]): string[] {
   if (argv === undefined)
     argv = process.argv.slice(2)
 
   return parseArgv(argv).args
 }
+
+interface CliOptions {
+  dryRun?: boolean
+  [k: string]: string | boolean | number | undefined
+}
+
+export function parseOptions(options?: CliOptions): object {
+  // If options are not provided, use command-line arguments
+  if (!options) {
+    options = {}
+    const args = process.argv.slice(2)
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i]
+      // Check if the argument is a flag (starts with --)
+      if (arg.startsWith('--')) {
+        const key = arg.substring(2) // Remove the -- prefix
+        // Convert kebab-case to camelCase
+        const camelCaseKey = key.replace(/-([a-z])/g, g => g[1].toUpperCase())
+        // Check if the next argument is a boolean value or another flag
+        if (i + 1 < args.length && (args[i + 1] === 'true' || args[i + 1] === 'false')) {
+          options[camelCaseKey] = args[i + 1] === 'true'
+          i++ // Skip the next argument since it's a value
+        }
+        else {
+          // If there's no explicit true/false value, assume the flag is true
+          options[camelCaseKey] = true
+        }
+      }
+    }
+  }
+  else {
+    // Normalize options: convert string "true"/"false" to boolean values
+    Object.keys(options).forEach((key) => {
+      const value = options[key]
+      if (value === 'true')
+        options[key] = true
+      else if (value === 'false')
+        options[key] = false
+    })
+  }
+
+  return options
+}
+
+export function buddyOptions(options?: any): string {
+  if (!options) {
+    options = process.argv.slice(2)
+    options = Array.from(new Set(options))
+    // delete the 0 element if it does not start with a -
+    // e.g. is used when buddy changelog --dry-run is used
+    if (!options[0].startsWith('-'))
+      options.shift()
+  }
+
+  if (options?.verbose) {
+    log.debug('process.argv', process.argv)
+    log.debug('process.argv.slice(2)', process.argv.slice(2))
+    log.debug('options inside buddyOptions', options)
+  }
+
+  return options.join(' ')
+}