@fugood/bricks-project 2.24.0 → 2.24.1-beta.0

package/compile/index.ts

@@ -1274,6 +1274,6 @@ export const compile = async (app: Application) => {
 }
 
 export const checkConfig = async (configPath: string) => {
-  const { $ } = await import('bun')
-  await $`bricks app check-config ${configPath}`
+  const { sh } = await import('../tools/_shell')
+  await sh`bricks app check-config ${configPath}`
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.24.0",
+  "version": "2.24.1-beta.0",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.24.0",
+    "@fugood/bricks-cli": "^2.24.1-beta.0",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -18,6 +18,7 @@
     "acorn": "^8.13.0",
     "escodegen": "2.1.0",
     "fuse.js": "^7.0.0",
+    "json5": "^2.0.1",
     "lodash": "^4.17.4",
     "uuid": "^8.3.1"
   },

package/package.json.bak

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.24.0",
+  "version": "2.24.1-beta.0",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.24.0",
+    "@fugood/bricks-cli": "^2.24.1-beta.0",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -18,6 +18,7 @@
     "acorn": "^8.13.0",
     "escodegen": "2.1.0",
     "fuse.js": "^7.0.0",
+    "json5": "^2.0.1",
     "lodash": "^4.17.4",
     "uuid": "^8.3.1"
   },

package/skills/bricks-ctor/rules/data-calculation.md

@@ -27,7 +27,8 @@ const calculation: DataCalculationScript = {
     }).format(price)
   `,
   // Or load from file (preferred for longer scripts)
-  // code: await Bun.file(`${import.meta.dir}/format-price.sandbox.js`).text(),
+  // import { readFile } from 'node:fs/promises'
+  // code: await readFile(new URL('./format-price.sandbox.js', import.meta.url), 'utf8'),
   inputs: [
     { key: 'price', data: () => priceData, trigger: true },
     { key: 'currency', data: () => currencyData, trigger: false },

package/tools/_git-author.ts

@@ -0,0 +1,29 @@
+import { sh } from './_shell'
+
+const CTOR_NAME = 'CTOR'
+const CTOR_EMAIL = 'ctor@bricks.tools'
+const CTOR_COAUTHOR_TRAILER = `Co-authored-by: ${CTOR_NAME} <${CTOR_EMAIL}>`
+
+async function hasGitIdentity(cwd: string): Promise<boolean> {
+  const out = (await sh`cd ${cwd} && git config user.email`.quiet().nothrow().text()).trim()
+  return !!out
+}
+
+// Build `git ...` args for a commit attributed to CTOR.
+// If the machine has a git identity configured (any config level), the user
+// remains the main author and CTOR is added via a Co-authored-by trailer.
+// If no identity is configured (typical for non-tech users), CTOR becomes the
+// main author via per-command `-c user.name/-c user.email` overrides so the
+// user's git config is left untouched.
+export async function buildCommitArgs(cwd: string, messages: string[]): Promise<string[]> {
+  const hasIdentity = await hasGitIdentity(cwd)
+  const prefix = hasIdentity
+    ? []
+    : ['-c', `user.name=${CTOR_NAME}`, '-c', `user.email=${CTOR_EMAIL}`]
+  const msgArgs: string[] = []
+  for (const m of messages) msgArgs.push('-m', m)
+  if (hasIdentity) msgArgs.push('-m', CTOR_COAUTHOR_TRAILER)
+  return [...prefix, 'commit', ...msgArgs]
+}
+
+export { CTOR_NAME, CTOR_EMAIL, CTOR_COAUTHOR_TRAILER }

package/tools/_shell.ts

@@ -0,0 +1,173 @@
+import { spawn, type StdioOptions } from 'node:child_process'
+
+// Template-literal shell helper replacing `$` from 'bun'. Only covers the
+// ergonomics actually used in this package (see call sites in tools/*.ts).
+//
+// Usage:
+//   await sh`git status`                        // inherit stdio, throw on nonzero
+//   await sh`cd ${cwd} && git status`.quiet().nothrow()
+//   const out = await sh`git rev-parse HEAD`.text()
+//   await sh`bunx bricks ${args}`.cwd(dir).text()
+//
+// Notes:
+// - Interpolated values are treated as single argv tokens (arrays expand to
+//   multiple tokens). Whitespace inside interpolated strings is preserved.
+// - A leading `cd <path> && <cmd...>` in the literal is lifted into the
+//   subprocess cwd — no shell is spawned, so no quoting concerns.
+// - Commands that chain with `&&` beyond the `cd` prefix aren't supported;
+//   split them into multiple `sh` awaits at the call site.
+
+export interface ShResult {
+  exitCode: number
+  stdout: Buffer
+  stderr: Buffer
+}
+
+type Mode = 'default' | 'text' | 'quiet'
+
+class Sh implements PromiseLike<ShResult> {
+  private _cwd: string | undefined
+  private _mode: Mode = 'default'
+  private _throw = true
+  private _promise: Promise<ShResult> | null = null
+
+  constructor(private readonly args: string[]) {}
+
+  cwd(dir: string): this {
+    this._cwd = dir
+    return this
+  }
+
+  quiet(): this {
+    this._mode = 'quiet'
+    return this
+  }
+
+  nothrow(): this {
+    this._throw = false
+    return this
+  }
+
+  async text(): Promise<string> {
+    // If no explicit quiet was requested, capture stdout/stderr without
+    // forwarding them to the parent's streams (matches Bun's `.text()`).
+    if (this._mode === 'default') this._mode = 'text'
+    const r = await this.run()
+    return r.stdout.toString('utf8')
+  }
+
+  then<TResult1 = ShResult, TResult2 = never>(
+    onfulfilled?: ((value: ShResult) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.run().then(onfulfilled, onrejected)
+  }
+
+  private run(): Promise<ShResult> {
+    if (!this._promise) this._promise = this.exec()
+    return this._promise
+  }
+
+  private async exec(): Promise<ShResult> {
+    const [cmd, ...rest] = this.args
+    if (!cmd) throw new Error('sh: empty command')
+
+    const stdio: StdioOptions =
+      this._mode === 'default'
+        ? ['inherit', 'pipe', 'pipe']
+        : this._mode === 'quiet'
+          ? ['ignore', 'pipe', 'pipe']
+          : ['inherit', 'pipe', 'pipe']
+
+    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio })
+
+    const outChunks: Buffer[] = []
+    const errChunks: Buffer[] = []
+    proc.stdout?.on('data', (c: Buffer) => {
+      outChunks.push(c)
+      if (this._mode === 'default') process.stdout.write(c)
+    })
+    proc.stderr?.on('data', (c: Buffer) => {
+      errChunks.push(c)
+      if (this._mode === 'default') process.stderr.write(c)
+    })
+
+    const exitCode: number = await new Promise((resolve, reject) => {
+      proc.on('error', reject)
+      proc.on('close', (code) => resolve(code ?? 0))
+    })
+
+    const stdout = Buffer.concat(outChunks)
+    const stderr = Buffer.concat(errChunks)
+    const result: ShResult = { exitCode, stdout, stderr }
+
+    if (exitCode !== 0 && this._throw) {
+      const err: any = new Error(`sh: command failed with exit ${exitCode}: ${this.args.join(' ')}`)
+      err.exitCode = exitCode
+      err.stdout = stdout
+      err.stderr = stderr
+      throw err
+    }
+
+    return result
+  }
+}
+
+const WHITESPACE = /\s/
+
+function tokenize(
+  strings: TemplateStringsArray,
+  values: unknown[],
+): { tokens: string[]; initialCwd?: string } {
+  const tokens: string[] = []
+  let current = ''
+  let inToken = false
+
+  const commit = () => {
+    if (inToken) {
+      tokens.push(current)
+      current = ''
+      inToken = false
+    }
+  }
+
+  const append = (s: string) => {
+    current += s
+    inToken = true
+  }
+
+  const appendValue = (val: unknown) => {
+    if (val == null) return
+    if (Array.isArray(val)) {
+      val.forEach((item, i) => {
+        if (i > 0) commit()
+        append(String(item))
+      })
+      return
+    }
+    append(String(val))
+  }
+
+  strings.forEach((literal, i) => {
+    for (let c = 0; c < literal.length; c++) {
+      const ch = literal[c]
+      if (WHITESPACE.test(ch)) commit()
+      else append(ch)
+    }
+    if (i < values.length) appendValue(values[i])
+  })
+  commit()
+
+  // Lift `cd <path> && <cmd...>` prefix into subprocess cwd
+  if (tokens.length >= 3 && tokens[0] === 'cd' && tokens[2] === '&&') {
+    return { tokens: tokens.slice(3), initialCwd: tokens[1] }
+  }
+  return { tokens }
+}
+
+export function sh(strings: TemplateStringsArray, ...values: unknown[]): Sh {
+  const { tokens, initialCwd } = tokenize(strings, values)
+  const s = new Sh(tokens)
+  if (initialCwd) s.cwd(initialCwd)
+  return s
+}

package/tools/deploy.ts

@@ -1,8 +1,21 @@
-import { $ } from 'bun'
+import { access, readFile, writeFile } from 'node:fs/promises'
 import { parseArgs } from 'util'
+import { sh } from './_shell'
+import { buildCommitArgs } from './_git-author'
 
 const cwd = process.cwd()
 
+const exists = async (p: string) => {
+  try {
+    await access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const readJson = async (p: string) => JSON.parse(await readFile(p, 'utf8'))
+
 const {
   values: {
     changelogs: changelogsArg,
@@ -14,7 +27,7 @@ const {
     help,
   },
 } = parseArgs({
-  args: Bun.argv.slice(2),
+  args: process.argv.slice(2),
   options: {
     changelogs: { type: 'string' },
     'changelogs-file': { type: 'string' },
@@ -40,7 +53,7 @@ if (help) {
 }
 
 // Check git status
-const { exitCode } = await $`cd ${cwd} && git status`.quiet().nothrow()
+const { exitCode } = await sh`cd ${cwd} && git status`.quiet().nothrow()
 const isGitRepo = exitCode === 0
 
 if (!isGitRepo && !yes) {
@@ -49,30 +62,30 @@ if (!isGitRepo && !yes) {
 }
 
 // Read application.json
-const app = await Bun.file(`${cwd}/application.json`).json()
-const config = await Bun.file(`${cwd}/.bricks/build/application-config.json`).json()
+const app = await readJson(`${cwd}/application.json`)
+const config = await readJson(`${cwd}/.bricks/build/application-config.json`)
 
 // Resolve version: explicit flag > auto-bump > package.json
-const pkgFile = Bun.file(`${cwd}/package.json`)
-const pkgExists = await pkgFile.exists()
+const pkgPath = `${cwd}/package.json`
+const pkgExists = await exists(pkgPath)
 let version: string | undefined
 
 if (versionArg) {
   version = versionArg
   if (pkgExists) {
-    const pkg = await pkgFile.json()
+    const pkg = await readJson(pkgPath)
     pkg.version = version
-    await Bun.write(`${cwd}/package.json`, JSON.stringify(pkg, null, 2) + '\n')
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
   }
 } else if (autoVersion && pkgExists) {
-  const pkg = await pkgFile.json()
+  const pkg = await readJson(pkgPath)
   const parts = (pkg.version || '0.0.0').split('.')
   parts[2] = String(Number(parts[2] || 0) + 1)
   version = parts.join('.')
   pkg.version = version
-  await Bun.write(`${cwd}/package.json`, JSON.stringify(pkg, null, 2) + '\n')
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
 } else {
-  version = pkgExists ? (await pkgFile.json()).version : undefined
+  version = pkgExists ? (await readJson(pkgPath)).version : undefined
 }
 
 // Get changelog from flag or file
@@ -80,11 +93,10 @@ let changelogs = ''
 if (changelogsArg) {
   changelogs = changelogsArg
 } else if (changelogsFile) {
-  const file = Bun.file(changelogsFile)
-  if (!(await file.exists())) {
+  if (!(await exists(changelogsFile))) {
     throw new Error(`Changelogs file not found: ${changelogsFile}`)
   }
-  changelogs = await file.text()
+  changelogs = await readFile(changelogsFile, 'utf8')
 } else if (!yes) {
   changelogs = prompt('Enter changelogs (optional, press Enter to skip):') || ''
 }
@@ -92,19 +104,21 @@ if (changelogsArg) {
 // Handle unstaged changes
 let commitId = ''
 if (isGitRepo) {
-  const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
   if (unstagedChanges) {
     if (autoCommit) {
       const commitMsg = `chore: release ${version || 'new version'}`
       const commitBody = changelogs || '[no changelogs]'
-      await $`cd ${cwd} && git add -A && git commit -m ${commitMsg} -m ${commitBody}`
+      await sh`cd ${cwd} && git add -A`
+      const commitArgs = await buildCommitArgs(cwd, [commitMsg, commitBody])
+      await sh`cd ${cwd} && git ${commitArgs}`
     } else {
       throw new Error(
         'Unstaged changes found, please commit or stash your changes before deploying',
       )
     }
   }
-  commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+  commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
 }
 
 // Ask for confirmation
@@ -123,7 +137,7 @@ const releaseConfig = {
   bricks_project_last_commit_id: commitId || undefined,
 }
 const configPath = `${cwd}/.bricks/build/release-config.json`
-await Bun.write(configPath, JSON.stringify(releaseConfig))
+await writeFile(configPath, JSON.stringify(releaseConfig))
 
 const args = ['bricks', command, 'release', app.id, '-c', configPath, '--json']
 
@@ -135,7 +149,7 @@ if (changelogs) {
   args.push('--changelogs', changelogs)
 }
 
-const result = await $`${args}`.quiet().nothrow()
+const result = await sh`${args}`.quiet().nothrow()
 
 if (result.exitCode !== 0) {
   const output = result.stderr.toString() || result.stdout.toString()

package/tools/mcp-tools/compile.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { readFile } from 'node:fs/promises'
 import { z } from 'zod'
-import { $ } from 'bun'
+import { sh } from '../_shell'
 
 export function register(server: McpServer, projectDir: string) {
   const { dirname } = import.meta
@@ -9,7 +10,7 @@ export function register(server: McpServer, projectDir: string) {
     let log = ''
     try {
       log += 'Type checking & Compiling...'
-      log += await $`bun compile`.cwd(projectDir).text()
+      log += await sh`bun compile`.cwd(projectDir).text()
     } catch (err) {
       log += `${err.stdout.toString()}\n${err.stderr.toString()}`
     }
@@ -60,7 +61,7 @@ export function register(server: McpServer, projectDir: string) {
         ]
         if (testId) args.push('--test-id', testId)
         if (testTitleLike) args.push('--test-title-like', testTitleLike)
-        log = await $`bunx --bun electron ${toolsDir}/preview-main.mjs ${args}`
+        log = await sh`bunx --bun electron ${toolsDir}/preview-main.mjs ${args}`
           .cwd(projectDir)
           .text()
       } catch (err) {
@@ -70,8 +71,8 @@ export function register(server: McpServer, projectDir: string) {
       let screenshotBase64: string | null = null
       if (!error && responseImage) {
         const toolsDir = `${dirname}/..`
-        const screenshot = await Bun.file(`${toolsDir}/screenshot.jpg`).arrayBuffer()
-        screenshotBase64 = Buffer.from(screenshot).toString('base64')
+        const screenshot = await readFile(`${toolsDir}/screenshot.jpg`)
+        screenshotBase64 = screenshot.toString('base64')
       }
       const content: Array<
         { type: 'text'; text: string } | { type: 'image'; data: string; mimeType: string }

package/tools/mcp-tools/huggingface.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
-import { JSON5 } from 'bun'
+import JSON5 from 'json5'
 import * as TOON from '@toon-format/toon'
 import { gguf } from '@huggingface/gguf'
 

package/tools/mcp-tools/media.ts

@@ -1,10 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
-import { $ } from 'bun'
+import { sh } from '../_shell'
 
 const runBricks = async (projectDir: string, ...args: string[]) => {
   try {
-    return await $`bunx bricks ${args}`.cwd(projectDir).text()
+    return await sh`bunx bricks ${args}`.cwd(projectDir).text()
   } catch (err: any) {
     throw new Error(err.stderr?.toString() || err.message)
   }

package/tools/postinstall.ts

@@ -1,4 +1,3 @@
-import { $ } from 'bun'
 import {
   cp,
   lstat,
@@ -53,8 +52,15 @@ if (skipCopyProject) {
 } else {
   const libFiles = ['types', 'utils', 'index.ts']
 
-  await $`mkdir -p ${cwd}/ctor`
-  await Promise.all(libFiles.map((file) => $`cp -r ${__dirname}/../${file} ${cwd}/ctor`))
+  const ctorDir = path.join(cwd, 'ctor')
+  await mkdir(ctorDir, { recursive: true })
+  await Promise.all(
+    libFiles.map((file) =>
+      cp(path.join(import.meta.dirname, '..', file), path.join(ctorDir, file), {
+        recursive: true,
+      }),
+    ),
+  )
   console.log('Copied files to ctor/')
 }
 
@@ -175,7 +181,7 @@ const ensureCompatibilitySkillLink = async (linkPath: string, targetDir: string)
 }
 
 const setupSkills = async () => {
-  const packageSkillsDir = `${__dirname}/../skills`
+  const packageSkillsDir = path.join(import.meta.dirname, '..', 'skills')
   await mkdir(projectSkillsDir, { recursive: true })
   await copyMissingSkills(packageSkillsDir, projectSkillsDir)
 

package/tools/preview.ts

@@ -1,11 +1,14 @@
-import { $ } from 'bun'
+import { spawn } from 'node:child_process'
+import { readFile, writeFile } from 'node:fs/promises'
 import { watch, unlinkSync } from 'fs'
 import type { FSWatcher } from 'fs'
+import { createInterface } from 'node:readline'
 import { parseArgs } from 'util'
 import debounce from 'lodash/debounce'
+import { sh } from './_shell'
 
 const { values } = parseArgs({
-  args: Bun.argv,
+  args: process.argv,
   options: {
     'skip-typecheck': { type: 'boolean' },
     'clear-cache': { type: 'boolean' },
@@ -28,7 +31,7 @@ const { values } = parseArgs({
 
 const cwd = process.cwd()
 
-const app = await Bun.file(`${cwd}/application.json`).json()
+const app = JSON.parse(await readFile(`${cwd}/application.json`, 'utf8'))
 
 const args: string[] = []
 if (values['clear-cache']) args.push('--clear-cache')
@@ -72,8 +75,8 @@ if (!values['no-cdp']) {
 const useTypecheck = !values['skip-typecheck']
 
 const compile = async () => {
-  if (useTypecheck) await $`bun typecheck`
-  await $`bun compile.ts`
+  if (useTypecheck) await sh`bun typecheck`
+  await sh`bun compile.ts`
 }
 
 await compile()
@@ -97,7 +100,7 @@ const cleanupDevtoolsInfo = () => {
 
 // Kill existing preview process if devtools.json contains a stale pid
 try {
-  const devtoolsInfo = await Bun.file(devtoolsInfoPath).json()
+  const devtoolsInfo = JSON.parse(await readFile(devtoolsInfoPath, 'utf8'))
   if (devtoolsInfo.pid) {
     try {
       process.kill(devtoolsInfo.pid)
@@ -106,49 +109,42 @@ try {
   }
 } catch {}
 
-const proc = Bun.spawn(['bunx', '--bun', 'electron', `${__dirname}/preview-main.mjs`, ...args], {
-  env: { ...process.env, BRICKS_STAGE: app.stage || 'production' },
-  stdout: 'pipe',
-  stderr: 'inherit',
-})
+const proc = spawn(
+  'bunx',
+  ['--bun', 'electron', `${import.meta.dirname}/preview-main.mjs`, ...args],
+  {
+    env: { ...process.env, BRICKS_STAGE: app.stage || 'production' },
+    stdio: ['inherit', 'pipe', 'inherit'],
+  },
+)
 
-const reader = proc.stdout.getReader()
-const decoder = new TextDecoder()
-
-const processOutput = async () => {
-  let done = false
-  while (!done) {
-    // eslint-disable-next-line no-await-in-loop
-    const result = await reader.read()
-    ;({ done } = result)
-    if (!done) {
-      const text = decoder.decode(result.value)
-      text.split('\n').forEach((line) => {
-        if (line.startsWith('[TEST_RESULT_TOON]')) {
-          const toonData = line.replace('[TEST_RESULT_TOON]', '')
-          console.log(toonData)
-        } else if (line) {
-          // Detect CDP server startup from preview-main output
-          const cdpMatch = line.match(/^CDP server: ws:\/\/localhost:(\d+)/)
-          if (cdpMatch) {
-            const info = {
-              port: parseInt(cdpMatch[1], 10),
-              pid: proc.pid,
-              address: 'localhost',
-              name: `${app.name || 'Unnamed'} (CTOR Preview)`,
-              startedAt: new Date().toISOString(),
-            }
-            Bun.write(devtoolsInfoPath, JSON.stringify(info, null, 2))
-          }
-          console.log(line)
-        }
-      })
+const rl = createInterface({ input: proc.stdout! })
+
+rl.on('line', (line) => {
+  if (line.startsWith('[TEST_RESULT_TOON]')) {
+    const toonData = line.replace('[TEST_RESULT_TOON]', '')
+    console.log(toonData)
+    return
+  }
+  if (!line) return
+  // Detect CDP server startup from preview-main output
+  const cdpMatch = line.match(/^CDP server: ws:\/\/localhost:(\d+)/)
+  if (cdpMatch) {
+    const info = {
+      port: parseInt(cdpMatch[1], 10),
+      pid: proc.pid,
+      address: 'localhost',
+      name: `${app.name || 'Unnamed'} (CTOR Preview)`,
+      startedAt: new Date().toISOString(),
     }
+    writeFile(devtoolsInfoPath, JSON.stringify(info, null, 2))
   }
-}
+  console.log(line)
+})
 
-await processOutput()
-await proc.exited
+await new Promise<void>((resolve) => {
+  proc.on('close', () => resolve())
+})
 
 cleanupDevtoolsInfo()
 if (watcher) watcher.close()

package/tools/pull.ts

@@ -1,21 +1,26 @@
-import { $ } from 'bun'
+import { readFile, writeFile } from 'node:fs/promises'
 import { format } from 'oxfmt'
+import { sh } from './_shell'
+import { buildCommitArgs } from './_git-author'
 
 const cwd = process.cwd()
 const args = process.argv.slice(2)
 const force = args.includes('--force') || args.includes('-f')
 
 // Check git status
-const { exitCode } = await $`cd ${cwd} && git status`.nothrow()
+const { exitCode } = await sh`cd ${cwd} && git status`.nothrow()
 const isGitRepo = exitCode === 0
 
 if (isGitRepo) {
-  const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
   if (unstagedChanges) {
     if (force) {
       console.log('Force mode: committing unstaged changes before pull...')
-      await $`cd ${cwd} && git add .`
-      await $`cd ${cwd} && git commit -m ${'chore(force-pull): saved unstaged changes before pull'}`
+      await sh`cd ${cwd} && git add .`
+      const preCommitArgs = await buildCommitArgs(cwd, [
+        'chore(force-pull): saved unstaged changes before pull',
+      ])
+      await sh`cd ${cwd} && git ${preCommitArgs}`
     } else {
       throw new Error('Unstaged changes found, please commit or stash your changes before pulling')
     }
@@ -28,14 +33,14 @@ if (isGitRepo) {
 }
 
 // Read application.json
-const app = await Bun.file(`${cwd}/application.json`).json()
+const app = JSON.parse(await readFile(`${cwd}/application.json`, 'utf8'))
 
 const isModule = app.type === 'module'
 const command = isModule ? 'module' : 'app'
 
 // Fetch project files using CLI
 console.log(`Pulling ${command} project (${app.id})...`)
-const result = await $`bricks ${command} project-pull ${app.id} --json`.quiet().nothrow()
+const result = await sh`bricks ${command} project-pull ${app.id} --json`.quiet().nothrow()
 
 if (result.exitCode !== 0) {
   const output = result.stderr.toString() || result.stdout.toString()
@@ -52,11 +57,11 @@ const { files, lastCommitId } = JSON.parse(result.stdout.toString())
 let useMain = false
 if (isGitRepo && !force) {
   console.log(`Checking commit ${lastCommitId}...`)
-  const found = (await $`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
+  const found = (await sh`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
     .trim()
     .match(/^[\da-f]{40}$/)
 
-  const commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+  const commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
 
   if (commitId === lastCommitId) throw new Error('Commit not changed')
 
@@ -64,18 +69,18 @@ if (isGitRepo && !force) {
     ? 'BRICKS_PROJECT_try-pull-module'
     : 'BRICKS_PROJECT_try-pull-application'
 
-  await $`cd ${cwd} && git branch -D ${branchName}`.nothrow()
+  await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
 
   if (found) {
-    await $`cd ${cwd} && git checkout -b ${branchName} ${lastCommitId}`.nothrow()
+    await sh`cd ${cwd} && git checkout -b ${branchName} ${lastCommitId}`.nothrow()
   } else {
-    await $`cd ${cwd} && git checkout -b ${branchName}`
+    await sh`cd ${cwd} && git checkout -b ${branchName}`
     useMain = true
   }
 }
 
-const oxfmtConfig = await Bun.file(`${cwd}/.oxfmtrc.json`)
-  .json()
+const oxfmtConfig = await readFile(`${cwd}/.oxfmtrc.json`, 'utf8')
+  .then(JSON.parse)
   .catch(() => ({
     trailingComma: 'all',
     tabWidth: 2,
@@ -91,23 +96,24 @@ await Promise.all(
       const result = await format(file.name, file.input, oxfmtConfig)
       content = result.code
     }
-    return Bun.write(`${cwd}/${file.name}`, content)
+    return writeFile(`${cwd}/${file.name}`, content)
   }),
 )
 
 if (isGitRepo) {
-  await $`cd ${cwd} && git add .`
-  const hasChanges = !!(await $`cd ${cwd} && git diff --cached --name-only`.text()).trim()
+  await sh`cd ${cwd} && git add .`
+  const hasChanges = !!(await sh`cd ${cwd} && git diff --cached --name-only`.text()).trim()
   if (hasChanges) {
     const commitMsg = force
       ? `chore(force-pull): apply force pull-${command}`
       : isModule
         ? 'chore(project): apply file changes from BRICKS module'
         : 'chore(project): apply file changes from BRICKS application'
-    await $`cd ${cwd} && git commit -m ${commitMsg}`
+    const commitArgs = await buildCommitArgs(cwd, [commitMsg])
+    await sh`cd ${cwd} && git ${commitArgs}`
   }
   if (!force && !useMain) {
-    await $`cd ${cwd} && git merge main`
+    await sh`cd ${cwd} && git merge main`
   }
 }