@fugood/bricks-ctor 2.25.0-beta.6 → 2.25.0-beta.61

package/package.json

@@ -1,29 +1,9 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.6",
-  "main": "index.ts",
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "build": "bun scripts/build.js"
-  },
+  "version": "2.25.0-beta.61",
+  "description": "Deprecated: ctor tooling moved to the `bricks ctor` commands in @fugood/bricks-cli. This package now only forwards legacy project scripts and triggers migration.",
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.6",
-    "@huggingface/gguf": "^0.3.2",
-    "@iarna/toml": "^3.0.0",
-    "@modelcontextprotocol/sdk": "^1.15.0",
-    "@toon-format/toon": "^2.1.0",
-    "@types/bun": "^1.3.9",
-    "@types/escodegen": "^0.0.10",
-    "@types/lodash": "^4.17.12",
-    "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"
-  },
-  "peerDependencies": {
-    "oxfmt": "^0.36.0"
+    "@fugood/bricks-cli": "^2.25.0-beta.61"
   },
-  "gitHead": "d8a3bbd695e9118cf725b7226866d804bbe56bbe"
+  "gitHead": "342701683311c7e0dc295bac19a2f9a9517d3160"
 }

package/tools/deploy.ts

@@ -1,165 +1,19 @@
-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,
-    'changelogs-file': changelogsFile,
-    'auto-commit': autoCommit,
-    'auto-version': autoVersion,
-    version: versionArg,
-    yes,
-    help,
-  },
-} = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    changelogs: { type: 'string' },
-    'changelogs-file': { type: 'string' },
-    'auto-commit': { type: 'boolean' },
-    'auto-version': { type: 'boolean' },
-    version: { type: 'string' },
-    yes: { type: 'boolean', short: 'y' },
-    help: { type: 'boolean', short: 'h' },
-  },
-  allowPositionals: true,
-})
-
-if (help) {
-  console.log(`Options:
-  --changelogs <text>        Changelogs text for the release
-  --changelogs-file <path>   Read changelogs from a file
-  --auto-commit              Auto-commit unstaged changes before deploying
-  --auto-version             Auto-bump patch version before deploying
-  --version <version>        Set explicit version for the release
-  -y, --yes                  Skip all prompts
-  -h, --help                 Show this help message`)
-  process.exit(0)
-}
-
-// Check git status
-const { exitCode } = await sh`cd ${cwd} && git status`.quiet().nothrow()
-const isGitRepo = exitCode === 0
-
-if (!isGitRepo && !yes) {
-  const confirmContinue = prompt('No git repository found, continue? (y/n)')
-  if (confirmContinue !== 'y') throw new Error('Deployment cancelled')
-}
-
-// Read application.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 pkgPath = `${cwd}/package.json`
-const pkgExists = await exists(pkgPath)
-let version: string | undefined
-
-if (versionArg) {
-  version = versionArg
-  if (pkgExists) {
-    const pkg = await readJson(pkgPath)
-    pkg.version = version
-    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
-  }
-} else if (autoVersion && pkgExists) {
-  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 writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
-} else {
-  version = pkgExists ? (await readJson(pkgPath)).version : undefined
-}
-
-// Get changelog from flag or file
-let changelogs = ''
-if (changelogsArg) {
-  changelogs = changelogsArg
-} else if (changelogsFile) {
-  if (!(await exists(changelogsFile))) {
-    throw new Error(`Changelogs file not found: ${changelogsFile}`)
-  }
-  changelogs = await readFile(changelogsFile, 'utf8')
-} else if (!yes) {
-  changelogs = prompt('Enter changelogs (optional, press Enter to skip):') || ''
-}
-
-// Handle unstaged changes
-let commitId = ''
-if (isGitRepo) {
-  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 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 sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-}
-
-// Ask for confirmation
-if (!yes) {
-  const confirm = prompt('Are you sure you want to deploy? (y/n)')
-  if (confirm !== 'y') throw new Error('Deployment cancelled')
-}
-
-const isModule = app.type === 'module'
-const command = isModule ? 'module' : 'app'
-
-// Add project-specific fields to config and write to temp file
-const releaseConfig = {
-  ...config,
-  title: version || config.title,
-  bricks_project_last_commit_id: commitId || undefined,
-}
-const configPath = `${cwd}/.bricks/build/release-config.json`
-await writeFile(configPath, JSON.stringify(releaseConfig))
-
-const args = ['bricks', command, 'release', app.id, '-c', configPath, '--json']
-
-if (version) {
-  args.push('--version', version)
-}
-
-if (changelogs) {
-  args.push('--changelogs', changelogs)
-}
-
-const result = await sh`${args}`.quiet().nothrow()
-
-if (result.exitCode !== 0) {
-  const output = result.stderr.toString() || result.stdout.toString()
-  try {
-    const json = JSON.parse(output)
-    throw new Error(json.error || 'Release failed')
-  } catch {
-    throw new Error(output || 'Release failed')
-  }
-}
-
-const output = JSON.parse(result.stdout.toString())
-console.log(`${isModule ? 'Module' : 'App'} deployed: ${output.name}`)
+#!/usr/bin/env bun
+// @fugood/bricks-ctor is deprecated — all tooling now lives in the `bricks ctor *` commands
+// (the @fugood/bricks-cli package). This thin forwarder keeps legacy project scripts working
+// and lets `bricks ctor postinstall` migrate the project onto the new commands.
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+// Prefer the CLI installed next to this shim (@fugood/bricks-cli is our only dependency)
+// over a PATH lookup, so the forwarder works without a global install.
+const localBricks = fileURLToPath(new URL('../../../.bin/bricks', import.meta.url))
+const bricks = existsSync(localBricks) ? localBricks : 'bricks'
+
+const result = spawnSync(bricks, ['ctor', 'deploy', ...process.argv.slice(2)], { stdio: 'inherit' })
+if (result.error) {
+  console.error(`bricks-ctor forwarder failed to run \`${bricks}\`: ${result.error.message}`)
+  process.exit(1)
+}
+process.exit(result.status ?? 1)

package/tools/mcp-server.ts

@@ -1,28 +1,19 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+#!/usr/bin/env bun
+// @fugood/bricks-ctor is deprecated — all tooling now lives in the `bricks ctor *` commands
+// (the @fugood/bricks-cli package). This thin forwarder keeps legacy project scripts working
+// and lets `bricks ctor postinstall` migrate the project onto the new commands.
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
 
-import { register as registerCompile } from './mcp-tools/compile'
-import { register as registerLottie } from './mcp-tools/lottie'
-import { register as registerIcons } from './mcp-tools/icons'
-import { register as registerHuggingface } from './mcp-tools/huggingface'
-import { register as registerMedia } from './mcp-tools/media'
+// Prefer the CLI installed next to this shim (@fugood/bricks-cli is our only dependency)
+// over a PATH lookup, so the forwarder works without a global install.
+const localBricks = fileURLToPath(new URL('../../../.bin/bricks', import.meta.url))
+const bricks = existsSync(localBricks) ? localBricks : 'bricks'
 
-const server = new McpServer({
-  name: 'bricks-ctor',
-  version: '1.0.0',
-})
-
-const { dirname } = import.meta
-const projectDir = String(dirname).split('/node_modules/')[0]
-
-// NOTE: Cursor (Or VSCode) seems set ELECTRON_RUN_AS_NODE to 1, so we need to unset it
-process.env.ELECTRON_RUN_AS_NODE = ''
-
-registerCompile(server, projectDir)
-registerLottie(server)
-registerIcons(server)
-registerHuggingface(server)
-registerMedia(server, projectDir)
-
-const transport = new StdioServerTransport()
-await server.connect(transport)
+const result = spawnSync(bricks, ['ctor', 'mcp', ...process.argv.slice(2)], { stdio: 'inherit' })
+if (result.error) {
+  console.error(`bricks-ctor forwarder failed to run \`${bricks}\`: ${result.error.message}`)
+  process.exit(1)
+}
+process.exit(result.status ?? 1)

package/tools/postinstall.ts

@@ -1,235 +1,21 @@
-import {
-  cp,
-  lstat,
-  mkdir,
-  readFile,
-  readdir,
-  readlink,
-  rm,
-  stat,
-  symlink,
-  writeFile,
-} from 'fs/promises'
-import * as path from 'path'
-import TOML from '@iarna/toml'
-
-const cwd = process.cwd()
-const projectSkillsDir = path.join(cwd, '.bricks', 'skills')
-const compatibilitySkillLinks = [
-  path.join(cwd, '.claude', 'skills'),
-  path.join(cwd, '.codex', 'skills'),
-]
-
-async function exists(f: string) {
-  try {
-    await stat(f)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function pathExists(f: string) {
-  try {
-    await lstat(f)
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Migrate old projects: remove legacy project/ directory
-const oldProjectDir = path.join(cwd, 'project')
-if (await exists(oldProjectDir)) {
-  await rm(oldProjectDir, { recursive: true, force: true })
-  console.log('Removed legacy project/ directory')
-}
-
-// handle flag --skip-copy
-const skipCopyProject = process.argv.includes('--skip-copy-project')
-if (skipCopyProject) {
-  console.log('Skipping copy of files to ctor/')
-} else {
-  const libFiles = ['types', 'utils', 'index.ts']
-
-  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/')
-}
-
-const projectMcpServer = {
-  command: 'bun',
-  args: [`${cwd}/node_modules/@fugood/bricks-ctor/tools/mcp-server.ts`],
-}
-
-type CodexMcpConfig = {
-  mcp_servers: Record<string, typeof projectMcpServer>
-}
-
-// Claude Code and AGENTS.md projects both use the shared project .mcp.json file.
-const defaultMcpConfig = {
-  mcpServers: {
-    'bricks-ctor': projectMcpServer,
-  },
-}
-
-const handleMcpConfigOverride = async (mcpConfigPath: string) => {
-  let mcpConfig: { mcpServers: Record<string, typeof projectMcpServer> } | null = null
-  if (await exists(mcpConfigPath)) {
-    const configStr = await readFile(mcpConfigPath, 'utf-8')
-    try {
-      mcpConfig = JSON.parse(configStr)
-      if (!mcpConfig?.mcpServers) throw new Error('mcpServers is not defined')
-      mcpConfig.mcpServers['bricks-ctor'] = projectMcpServer
-      delete mcpConfig.mcpServers['bricks-project']
-    } catch {
-      mcpConfig = defaultMcpConfig
-    }
-  } else {
-    mcpConfig = defaultMcpConfig
-  }
-
-  await writeFile(mcpConfigPath, `${JSON.stringify(mcpConfig, null, 2)}\n`)
-
-  console.log(`Updated ${mcpConfigPath}`)
-}
-
-const hasClaudeCode = await exists(`${cwd}/CLAUDE.md`)
-const hasAgentsMd = await exists(`${cwd}/AGENTS.md`)
-
-if (hasClaudeCode || hasAgentsMd) {
-  // Keep the workspace-level JSON MCP config aligned for tools that read .mcp.json.
-  const mcpConfigPath = `${cwd}/.mcp.json`
-  await handleMcpConfigOverride(mcpConfigPath)
-}
-
-const copyMissingSkills = async (sourceDir: string, targetDir: string) => {
-  if (!(await exists(sourceDir))) return
-
-  const packageSkills = await readdir(sourceDir, { withFileTypes: true })
-  const skillsToInstall = packageSkills.filter(
-    (entry) => entry.isDirectory() && !entry.name.startsWith('.'),
-  )
-
-  await mkdir(targetDir, { recursive: true })
-
-  await Promise.all(
-    skillsToInstall.map(async (entry) => {
-      const targetSkillDir = path.join(targetDir, entry.name)
-      if (await exists(targetSkillDir)) {
-        console.log(`Skill '${entry.name}' already exists, skipping`)
-      } else {
-        await cp(path.join(sourceDir, entry.name), targetSkillDir, { recursive: true })
-        console.log(`Installed skill '${entry.name}' to ${targetDir}/`)
-      }
-    }),
-  )
-}
-
-const migrateSkillsDir = async (legacySkillsDir: string, canonicalSkillsDir: string) => {
-  if (!(await pathExists(legacySkillsDir))) return
-
-  const legacyStats = await lstat(legacySkillsDir)
-
-  if (legacyStats.isSymbolicLink()) {
-    const linkTarget = await readlink(legacySkillsDir)
-    const resolvedTarget = path.resolve(path.dirname(legacySkillsDir), linkTarget)
-    if (resolvedTarget === canonicalSkillsDir) return
-
-    await copyMissingSkills(resolvedTarget, canonicalSkillsDir)
-    await rm(legacySkillsDir, { force: true, recursive: true })
-    return
-  }
-
-  if (legacyStats.isDirectory()) {
-    await copyMissingSkills(legacySkillsDir, canonicalSkillsDir)
-    await rm(legacySkillsDir, { force: true, recursive: true })
-    return
-  }
-
-  console.warn(`Skipping skills migration for ${legacySkillsDir}; expected a directory or symlink`)
-}
-
-const ensureCompatibilitySkillLink = async (linkPath: string, targetDir: string) => {
-  await mkdir(path.dirname(linkPath), { recursive: true })
-
-  if (await pathExists(linkPath)) {
-    const linkStats = await lstat(linkPath)
-    if (linkStats.isSymbolicLink()) {
-      const linkTarget = await readlink(linkPath)
-      const resolvedTarget = path.resolve(path.dirname(linkPath), linkTarget)
-      if (resolvedTarget === targetDir) return
-    } else {
-      console.warn(
-        `Skipping skills symlink at ${linkPath}; path already exists and is not a symlink`,
-      )
-      return
-    }
-  }
-
-  const relativeTarget = path.relative(path.dirname(linkPath), targetDir)
-  const symlinkType = process.platform === 'win32' ? 'junction' : 'dir'
-  await symlink(relativeTarget, linkPath, symlinkType)
-  console.log(`Linked ${linkPath} -> ${relativeTarget}`)
-}
-
-const setupSkills = async () => {
-  const packageSkillsDir = path.join(import.meta.dirname, '..', 'skills')
-  await mkdir(projectSkillsDir, { recursive: true })
-  await copyMissingSkills(packageSkillsDir, projectSkillsDir)
-
-  for (const linkPath of compatibilitySkillLinks) {
-    await migrateSkillsDir(linkPath, projectSkillsDir)
-    await ensureCompatibilitySkillLink(linkPath, projectSkillsDir)
-  }
-}
-
-if (hasClaudeCode || hasAgentsMd) {
-  // Install project skills once and expose them through compatibility symlinks.
-  await setupSkills()
-}
-
-if (hasAgentsMd) {
-  // Codex stores its project-local MCP config in .codex/config.toml.
-  const defaultCodexMcpConfig = {
-    mcp_servers: {
-      'bricks-ctor': projectMcpServer,
-    },
-  }
-
-  const handleCodexMcpConfigOverride = async (mcpConfigPath: string) => {
-    let mcpConfig: CodexMcpConfig | null = null
-    if (await exists(mcpConfigPath)) {
-      const configStr = await readFile(mcpConfigPath, 'utf-8')
-      try {
-        const parsed = TOML.parse(configStr) as Partial<CodexMcpConfig>
-        if (!parsed?.mcp_servers) throw new Error('mcp_servers is not defined')
-        mcpConfig = { mcp_servers: parsed.mcp_servers }
-        mcpConfig.mcp_servers['bricks-ctor'] = projectMcpServer
-        delete mcpConfig.mcp_servers['bricks-project']
-      } catch {
-        mcpConfig = defaultCodexMcpConfig
-      }
-    } else {
-      mcpConfig = defaultCodexMcpConfig
-    }
-
-    await writeFile(mcpConfigPath, `${TOML.stringify(mcpConfig)}\n`)
-
-    console.log(`Updated ${mcpConfigPath}`)
-  }
-
-  // Keep the Codex TOML MCP config aligned with the same bricks-ctor server entry.
-  const codexConfigPath = `${cwd}/.codex/config.toml`
-  await handleCodexMcpConfigOverride(codexConfigPath)
-}
-
-// TODO: .cursor/skills if needed
-// TODO: User setting in application.json to avoid unnecessary skills/config setup
+#!/usr/bin/env bun
+// @fugood/bricks-ctor is deprecated — all tooling now lives in the `bricks ctor *` commands
+// (the @fugood/bricks-cli package). This thin forwarder keeps legacy project scripts working
+// and lets `bricks ctor postinstall` migrate the project onto the new commands.
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+// Prefer the CLI installed next to this shim (@fugood/bricks-cli is our only dependency)
+// over a PATH lookup, so the forwarder works without a global install.
+const localBricks = fileURLToPath(new URL('../../../.bin/bricks', import.meta.url))
+const bricks = existsSync(localBricks) ? localBricks : 'bricks'
+
+const result = spawnSync(bricks, ['ctor', 'postinstall', ...process.argv.slice(2)], {
+  stdio: 'inherit',
+})
+if (result.error) {
+  console.error(`bricks-ctor forwarder failed to run \`${bricks}\`: ${result.error.message}`)
+  process.exit(1)
+}
+process.exit(result.status ?? 1)

package/tools/pull.ts

@@ -1,122 +1,19 @@
-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 sh`cd ${cwd} && git status`.nothrow()
-const isGitRepo = exitCode === 0
-
-if (isGitRepo) {
-  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 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')
-    }
-  }
-} else {
-  const confirmContinue = prompt(
-    'No git repository found, so it will not be safe to pull, continue? (y/n)',
-  )
-  if (confirmContinue !== 'y') throw new Error('Pull cancelled')
+#!/usr/bin/env bun
+// @fugood/bricks-ctor is deprecated — all tooling now lives in the `bricks ctor *` commands
+// (the @fugood/bricks-cli package). This thin forwarder keeps legacy project scripts working
+// and lets `bricks ctor postinstall` migrate the project onto the new commands.
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+// Prefer the CLI installed next to this shim (@fugood/bricks-cli is our only dependency)
+// over a PATH lookup, so the forwarder works without a global install.
+const localBricks = fileURLToPath(new URL('../../../.bin/bricks', import.meta.url))
+const bricks = existsSync(localBricks) ? localBricks : 'bricks'
+
+const result = spawnSync(bricks, ['ctor', 'pull', ...process.argv.slice(2)], { stdio: 'inherit' })
+if (result.error) {
+  console.error(`bricks-ctor forwarder failed to run \`${bricks}\`: ${result.error.message}`)
+  process.exit(1)
 }
-
-// Read application.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 sh`bricks ${command} project-pull ${app.id} --json`.quiet().nothrow()
-
-if (result.exitCode !== 0) {
-  const output = result.stderr.toString() || result.stdout.toString()
-  try {
-    const json = JSON.parse(output)
-    throw new Error(json.error || 'Pull failed')
-  } catch {
-    throw new Error(output || 'Pull failed')
-  }
-}
-
-const { files, lastCommitId } = JSON.parse(result.stdout.toString())
-
-let useMain = false
-if (isGitRepo && !force) {
-  console.log(`Checking commit ${lastCommitId}...`)
-  const found = (await sh`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
-    .trim()
-    .match(/^[\da-f]{40}$/)
-
-  const commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-
-  if (commitId === lastCommitId) throw new Error('Commit not changed')
-
-  const branchName = isModule
-    ? 'BRICKS_PROJECT_try-pull-module'
-    : 'BRICKS_PROJECT_try-pull-application'
-
-  await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
-
-  if (found) {
-    await sh`cd ${cwd} && git checkout -b ${branchName} ${lastCommitId}`.nothrow()
-  } else {
-    await sh`cd ${cwd} && git checkout -b ${branchName}`
-    useMain = true
-  }
-}
-
-const oxfmtConfig = await readFile(`${cwd}/.oxfmtrc.json`, 'utf8')
-  .then(JSON.parse)
-  .catch(() => ({
-    trailingComma: 'all',
-    tabWidth: 2,
-    semi: false,
-    singleQuote: true,
-    printWidth: 100,
-  }))
-
-await Promise.all(
-  files.map(async (file: { name: string; input: string; formatable?: boolean }) => {
-    let content = file.input
-    if (file.formatable) {
-      const result = await format(file.name, file.input, oxfmtConfig)
-      content = result.code
-    }
-    return writeFile(`${cwd}/${file.name}`, content)
-  }),
-)
-
-if (isGitRepo) {
-  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'
-    const commitArgs = await buildCommitArgs(cwd, [commitMsg])
-    await sh`cd ${cwd} && git ${commitArgs}`
-  }
-  if (!force && !useMain) {
-    await sh`cd ${cwd} && git merge main`
-  }
-}
-
-console.log(
-  `${isModule ? 'Module' : 'App'} project pulled: ${files.length} files${force ? ' (force)' : ''}`,
-)
+process.exit(result.status ?? 1)