fix: add default options for execa

Author: zaaack

Foyfile.ts

@@ -145,7 +145,9 @@ task('demo2', async (ctx) => sleep(3000))
 task('demo3', ['demo2', 'demodemodemodemodemodemodemo1'], async (ctx) => sleep(3000))
 
 task('demo', ['demodemodemodemodemodemodemo1', dep('demo2').async(), dep('demo3').async()])
-
+task('$', async (ctx) => {
+  await ctx.env('aa', '1').$`echo test`
+})
 task('error', async (ctx) => {
   throw new Error('aa')
 })

README.md

@@ -378,12 +378,64 @@ task('build', async ctx => {
 A simple wrapper for sindresorhus's lovely module
 [execa](https://github.com/sindresorhus/execa)
 
+#### Using `ctx.$` (template literal syntax)
+
+`ctx.$` is a tagged template literal function that provides a shell-like syntax for executing commands. It's also available as a standalone export `$` from foy.
+
+```ts
+
+task('build', async ctx => {
+  // Using ctx.$ (same as standalone $)
+  await ctx.$`tsc`
+  await ctx.$`node ./test.js`
+
+  // Variable interpolation - values are automatically escaped
+  const file = 'my file.txt'  // note the space in filename
+  await ctx.$`cat ${file}`  // safely escapes to: cat 'my file.txt'
+
+  const count = 5
+  await ctx.$`echo ${count}`  // outputs: 5
+
+  // Using with options
+  const { stdout } = await ctx.$`ls -la`
+  console.log(stdout)
+
+  // Complex example with multiple variables
+  const src = './src'
+  const dest = './dist'
+  await ctx.$`cp -r ${src} ${dest}`
+})
+```
+
+**Key features of `ctx.$`:**
+- **Automatic escaping**: Variables are safely escaped for shell execution
+- **Template literal syntax**: More readable and familiar for shell commands
+- **Returns execa result**: Access `stdout`, `stderr`, `exitCode`, etc.
+- **Default options**: `stdio: 'inherit'` and `shell: true` are set by default
+
+**Differences from `ctx.exec`:**
+
+```ts
+// ctx.$ - template literal syntax, auto-escaping
+await ctx.$`echo ${userInput}`  // safely escapes special characters
+
+// ctx.exec - string syntax, no auto-escaping
+await ctx.exec(`echo ${userInput}`)  // be careful with special characters!
+
+// ctx.exec supports multiline commands
+await ctx.exec(`
+  echo "step 1"
+  echo "step 2"
+  echo "step 3"
+`)
+```
+
+#### Using `ctx.exec`
+
 ```ts
 import { logger, $ } from 'foy'
 
 task('build', async ctx => {
-  await $`tsc`
-  await $`node ./test.js`
   await ctx.exec('tsc')
 
   // run multiple commands synchronously

src/exec.ts

@@ -5,26 +5,51 @@ import {
   type Options,
   type ResultPromise,
   type Result,
+  type ExecaScriptMethod,
   execaNode,
+  TemplateExpression,
+  VerboseObject,
 } from 'execa'
 import pathLib from 'path'
 import { logger, logger as _logger } from './logger'
 import { sleep, Is, DefaultLogFile } from './utils'
 import { fs, WatchDirOptions } from './fs'
 import { Stream, Writable } from 'stream'
 import { ChildProcess, ExecOptions, spawn } from 'child_process'
-import shellParser from 'shell-parser'
-import { stdin } from 'process'
-export { execa, _$ }
-export const $ = _$({
+import { createRequire } from 'module'
+
+function _logCmd(cmd: string, env?: object) {
+  let envStr = Object.keys(env || {})
+    .map((k) => `${k}=${env?.[k] || ''}`)
+    .join(' ')
+  if (envStr) {
+    envStr += ' '
+  }
+  logger.info(`$ ${envStr}${cmd}`)
+}
+
+function joinTag(strings: TemplateStringsArray, ...values: TemplateExpression[]): string {
+  return strings.reduce((acc, str, i) => acc + str + (values[i] ?? ''), '')
+}
+
+const verbose = (verboseLine: string, verboseObject: VerboseObject) => {
+  if (verboseObject.type === 'command') {
+    _logCmd(verboseObject.escapedCommand, verboseObject.options.env)
+  }
+}
+
+const DefaultExecaOptions: Options = {
   stdio: 'inherit',
   shell: true,
-})
+  verbose: verbose,
+  extendEnv: true,
+}
 
+export const $ = _$(DefaultExecaOptions)
 export function exec(cmd: string, options?: Options): ResultPromise<Options> {
+  // _logCmd(cmd, options?.env)
   return execaCommand(cmd, {
-    stdio: 'inherit',
-    shell: true,
+    ...DefaultExecaOptions,
     ...options,
   })
 }
@@ -33,6 +58,7 @@ export class ShellContext {
   private _cwdStack = [process.cwd()]
   private _env: { [k: string]: string | undefined } = {}
   logCommand = false
+  execaOptions: Options | undefined
   sleep = sleep
   /**
    * get current word directory
@@ -71,7 +97,14 @@ export class ShellContext {
     return this
   }
 
-  $ = $
+  get $() {
+    return $({
+      env: {
+        ...this._env,
+      },
+      verbose: this.logCommand ? verbose : undefined,
+    })
+  }
 
   /**
    * NOTE!!!: New multiple commands are written as a single string with multiple lines,
@@ -91,19 +124,13 @@ export class ShellContext {
    * ```
    */
   exec(command: string, options?: Options): ResultPromise<Options> {
-    // async exec(commands: string[], options?: Options): Promise<Result[]>
-    // async exec(
-    //   commands: string | string[],
-    //   options?: Options,
-    // ): Promise<Result[]> | ResultPromise<Options>
-    this._logCmd(command)
     let p = exec(command, {
       cwd: this.cwd,
       env: {
-        ...process.env,
         ...this._env,
       },
       stdio: 'inherit',
+      verbose: this.logCommand ? verbose : undefined,
       ...options,
     })
     // tslint:disable-next-line:no-floating-promises
@@ -182,20 +209,6 @@ export class ShellContext {
     this._env = {}
     return this
   }
-  private _logCmd(cmd: string | string[]) {
-    if (this.logCommand) {
-      let env = Object.keys(this._env)
-        .map((k) => `${k}=${this._env[k] || ''}`)
-        .join(' ')
-      if (env) {
-        env += ' '
-      }
-      cmd = Array.isArray(cmd) ? cmd : [cmd]
-      cmd.forEach((cmd) => {
-        this._logger.info(`$ ${env}${cmd}`)
-      })
-    }
-  }
 }
 
 export async function shell(callback: (ctx: ShellContext) => Promise<any>) {

src/task-manager.ts

@@ -2,16 +2,16 @@ import { CliLoading } from './cli-loading'
 import type { Task } from './task'
 import { task } from './task'
 import chalk from 'chalk'
-import { createRequire } from 'module'
-const require = createRequire(import.meta.url)
-const pkg = require('../package.json')
+// import { createRequire } from 'module'
+// const require = createRequire(import.meta.url)
+import pkg from '../package.json'
 import { hashAny, defaults, Is, DefaultLogFile, formatDuration } from './utils'
 import { Writable, Stream } from 'stream'
 import { fs } from './fs'
 import { ShellContext } from './exec'
 import { logger, ILogInfo, ILoggerProps, LogLevels, Logger } from './logger'
 import figures from 'figures'
-
+import { type Options as ExecaOptions } from 'execa'
 export interface GlobalOptions {
   /**
    * spinner
@@ -21,6 +21,7 @@ export interface GlobalOptions {
   /** @deprecated use spinner */
   loading?: boolean
   indent?: number
+  execa?: ExecaOptions
   /**
    * Whether task options only allow defined options, default false
    * @default false
@@ -87,9 +88,13 @@ export class TaskContext<O = any> extends ShellContext {
   get error() {
     return this._logger.error
   }
-  constructor(public task: Task<O>, public global: GlobalOptions) {
+  constructor(
+    public task: Task<O>,
+    public global: GlobalOptions,
+  ) {
     super()
     this.logCommand = defaults(task.logger && task.logCommand, global.logCommand, true)
+    this.execaOptions = defaults(task.execaOptions, global.execa)
     this._logger = new Logger(global.logger)
   }
   /**
@@ -300,9 +305,7 @@ export class TaskManager {
       force: false,
       ...props,
     }
-    this._tasks.all =
-      this._tasks.all ||
-      (task('all', Object.keys(this._tasks)))
+    this._tasks.all = this._tasks.all || task('all', Object.keys(this._tasks))
     this._tasks.default = this._tasks.default || this._tasks.all
 
     if (!this._tasks[Is.str(name) ? name : name.name]) {
@@ -347,9 +350,9 @@ export class TaskManager {
   }
 }
 
-const TMKey = `@foy${pkg.version}/taskManager`
 /** @internal */
 export function getGlobalTaskManager() {
-  let taskManager: TaskManager = (global[TMKey] = global[TMKey] || new TaskManager())
+  const TMKey = `@foy${pkg.version}/taskManager`
+  let taskManager: TaskManager = (globalThis[TMKey] = globalThis[TMKey] || new TaskManager())
   return taskManager
 }

src/task.ts

@@ -1,15 +1,20 @@
-import chalk from 'chalk'
 import { ShellContext } from './exec'
 import { hashAny, Is, defaults } from './utils'
 import { fs } from './fs'
 import { ILoggerProps, logger } from './logger'
 import { CliLoading } from './cli-loading'
 import { DepBuilder } from './dep-builder'
-import { GlobalOptions, RunTaskOptions, getGlobalTaskManager, TaskContext, ListenerNames } from './task-manager'
+import {
+  GlobalOptions,
+  RunTaskOptions,
+  getGlobalTaskManager,
+  TaskContext,
+  ListenerNames,
+} from './task-manager'
 import { deferRunCli } from './run-cli'
 interface OptionConfig {
-  default?: any;
-  type?: any[];
+  default?: any
+  type?: any[]
 }
 export type OptionDef = [string, string, OptionConfig | undefined]
 
@@ -73,7 +78,7 @@ export function setGlobalOptions(options: GlobalOptions) {
   options.spinner ??= options.loading
   Object.assign(getGlobalTaskManager().globalOptions, options)
 }
-function appendCallback<Fn extends ((...args) => void | Promise<void>)>(name: ListenerNames, fn: Fn) {
+function appendCallback<Fn extends (...args) => void | Promise<void>>(name: ListenerNames, fn: Fn) {
   let tm = getGlobalTaskManager()
   tm.listeners[name].push({
     namespaces: tm.namespaces,
@@ -82,7 +87,8 @@ function appendCallback<Fn extends ((...args) => void | Promise<void>)>(name: Li
 }
 export const before = (fn: (t: Task) => void | Promise<void>) => appendCallback('before', fn)
 export const after = (fn: (t: Task) => void | Promise<void>) => appendCallback('after', fn)
-export const onerror = (fn: (err: Error, t: Task) => void | Promise<void>) => appendCallback('onerror', fn)
+export const onerror = (fn: (err: Error, t: Task) => void | Promise<void>) =>
+  appendCallback('onerror', fn)
 
 namespace TaskOptions {
   export let last = empty()
@@ -161,7 +167,7 @@ export function task<O>(
     strict: TaskOptions.last.strict,
     spinner: TaskOptions.last.spinner,
     rawArgs: [],
-    dependencies: dependencies.map(d => {
+    dependencies: dependencies.map((d) => {
       if (Is.str(d)) {
         return { name: d, options: {} } as Task
       } else if (d._isDepBuilder) {

src/test/fixtures/Foyfile2.ts

@@ -26,6 +26,11 @@ task('exec', async (ctx) => {
   let sleep = ctx.exec('sleep 1')
   logger.info(sleep.killed, typeof sleep.then, typeof sleep.kill)
 })
+task('$', async (ctx) => {
+  let echo1 = await ctx.$`echo 1`
+  logger.info(`echo1`, echo1.stdout)
+  await ctx.$`sleep 1`
+})
 namespace('ns1', (ns) => {
   before((t) => {
     logger.log(`before ${ns}`, t.name)

src/test/fixtures/snaps/Foyfile1_ts_ee

@@ -1,3 +1,3 @@
 DependencyGraph for task [ee]:
 Task: ee
-[info] $
+[info] $ echo 'aa\n' echo bb

src/test/fixtures/snaps/Foyfile1_ts_fails

@@ -1,4 +1,4 @@
 DependencyGraph for task [fails]:
 Task: fails
 [info] Fail this task
-[info] $ node -e "console.log(\"start\"); process.exit(1)"
+[info] $ node -e '"console.log(\"start\");' 'process.exit(1)"'

src/test/fixtures/snaps/Foyfile2_ts__

@@ -0,0 +1,7 @@
+DependencyGraph for task [$]:
+[info] beforeAll $
+Task: $
+[info] $ echo 1
+[info] echo1 undefined
+[info] $ sleep 1
+[info] afterAll $

src/test/task.test.ts

@@ -47,8 +47,8 @@ function test(cmd: string, expectedExitCode?: number) {
     async init() {
       let p = await exec(`tsx ./src/cli.ts --config ${fixturesDir}/${cmd}`, {
         stdio: void 0,
+        verbose: 'none',
         env: {
-          ...process.env,
           DISABLE_V8_COMPILE_CACHE: '1',
         },
       }).catch((er) => er)
@@ -93,6 +93,7 @@ describe('task', function () {
     test(`Foyfile2.ts ns1:error`),
     test(`Foyfile2.ts ns1:ns2:t2`),
     test(`Foyfile2.ts exec`),
+    test(`Foyfile2.ts $`),
   ]
   before(
     async () => {