fix: add default options for execa

Author: zaaack

README.md

@@ -378,12 +378,69 @@ 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
-import { logger, $ } from 'foy'
+import { $ } from 'foy'
 
 task('build', async ctx => {
+  // Basic usage - simple command
   await $`tsc`
   await $`node ./test.js`
+
+  // 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 $`cat ${file}`  // safely escapes to: cat 'my file.txt'
+
+  const count = 5
+  await $`echo ${count}`  // outputs: 5
+
+  // Using with options
+  const { stdout } = await $`ls -la`
+  console.log(stdout)
+
+  // Complex example with multiple variables
+  const src = './src'
+  const dest = './dist'
+  await $`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 $`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 ctx.exec('tsc')
 
   // run multiple commands synchronously

src/exec.ts

@@ -5,6 +5,7 @@ import {
   type Options,
   type ResultPromise,
   type Result,
+  type ExecaScriptMethod,
   execaNode,
 } from 'execa'
 import pathLib from 'path'
@@ -14,12 +15,19 @@ 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 $ = _$({
-  stdio: 'inherit',
-  shell: true,
-})
+import { setGlobalOptions } from './task'
+import { getGlobalTaskManager } from './task-manager'
+export const $: ExecaScriptMethod<{
+  stdio: 'inherit'
+  shell: true
+}> = ((...args: any) => {
+  const options = getGlobalTaskManager().globalOptions.execa
+  return (_$ as any)({
+    stdio: 'inherit',
+    shell: true,
+    ...options,
+  })(...args)
+}) as any
 
 export function exec(cmd: string, options?: Options): ResultPromise<Options> {
   return execaCommand(cmd, {

src/task-manager.ts

@@ -11,7 +11,7 @@ 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,7 +88,10 @@ 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._logger = new Logger(global.logger)
@@ -300,9 +304,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]) {

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) {