@fugood/bricks-ctor 2.25.0-beta.7 → 2.25.0-beta.70

package/package.json

@@ -1,29 +1,9 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.7",
-  "main": "index.ts",
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "build": "bun scripts/build.js"
-  },
+  "version": "2.25.0-beta.70",
+  "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.70"
   },
-  "gitHead": "e43200271cec0b015b1044e1b0041cad575f030f"
+  "gitHead": "3587a7e806a776b3ecc868738def1d4630f485ec"
 }

package/tools/__tests__/legacy-forwarder.test.js

@@ -0,0 +1,91 @@
+const mockSpawnSync = jest.fn()
+const mockExistsSync = jest.fn()
+
+jest.mock('node:child_process', () => ({
+  __esModule: true,
+  spawnSync: (...args) => mockSpawnSync(...args),
+}))
+
+jest.mock('node:fs', () => ({
+  __esModule: true,
+  existsSync: (...args) => mockExistsSync(...args),
+}))
+
+const loadForwarder = () => require('../_forward.ts')
+
+describe('legacy bricks-ctor forwarder', () => {
+  let exitSpy
+  let errorSpy
+
+  beforeEach(() => {
+    jest.resetModules()
+    mockSpawnSync.mockReset()
+    mockExistsSync.mockReset()
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {})
+    errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    exitSpy.mockRestore()
+    errorSpy.mockRestore()
+  })
+
+  it('prefers the local bricks CLI next to the legacy package', () => {
+    mockExistsSync.mockReturnValue(true)
+    mockSpawnSync.mockReturnValue({ status: 0 })
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool(
+      'deploy',
+      'file:///repo/node_modules/@fugood/bricks-ctor/tools/deploy.ts',
+      ['--target', 'device'],
+    )
+
+    expect(mockSpawnSync).toHaveBeenCalledWith(
+      '/repo/node_modules/.bin/bricks',
+      ['ctor', 'deploy', '--target', 'device'],
+      { stdio: 'inherit' },
+    )
+    expect(exitSpy).toHaveBeenCalledWith(0)
+  })
+
+  it('falls back to PATH when the local bricks CLI is missing', () => {
+    mockExistsSync.mockReturnValue(false)
+    mockSpawnSync.mockReturnValue({ status: 3 })
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool('pull', 'file:///repo/node_modules/@fugood/bricks-ctor/tools/pull.ts', [])
+
+    expect(mockSpawnSync).toHaveBeenCalledWith('bricks', ['ctor', 'pull'], { stdio: 'inherit' })
+    expect(exitSpy).toHaveBeenCalledWith(3)
+  })
+
+  it('reports spawn errors and exits with failure', () => {
+    mockExistsSync.mockReturnValue(false)
+    mockSpawnSync.mockReturnValue({ error: new Error('ENOENT') })
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool(
+      'mcp',
+      'file:///repo/node_modules/@fugood/bricks-ctor/tools/mcp-server.ts',
+      [],
+    )
+
+    expect(errorSpy).toHaveBeenCalledWith('bricks-ctor forwarder failed to run `bricks`: ENOENT')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+
+  it('treats a missing child status as failure', () => {
+    mockExistsSync.mockReturnValue(false)
+    mockSpawnSync.mockReturnValue({})
+    const { forwardLegacyCtorTool } = loadForwarder()
+
+    forwardLegacyCtorTool(
+      'simulator',
+      'file:///repo/node_modules/@fugood/bricks-ctor/tools/simulator.ts',
+      [],
+    )
+
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+})

package/tools/_forward.ts

@@ -0,0 +1,26 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+// @fugood/bricks-ctor is deprecated; all tooling now lives in @fugood/bricks-cli.
+// This shared forwarder keeps legacy project scripts working until postinstall migrates them.
+export function resolveLegacyBricksCommand(baseUrl: string) {
+  const localBricks = fileURLToPath(new URL('../../../.bin/bricks', baseUrl))
+  return existsSync(localBricks) ? localBricks : 'bricks'
+}
+
+export function forwardLegacyCtorTool(
+  command: string,
+  baseUrl: string,
+  args = process.argv.slice(2),
+) {
+  const bricks = resolveLegacyBricksCommand(baseUrl)
+  const result = spawnSync(bricks, ['ctor', command, ...args], { 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/deploy.ts

@@ -1,165 +1,4 @@
-import { access, readFile, writeFile } from 'node:fs/promises'
-import { parseArgs } from 'util'
-import { sh } from './_shell'
-import { buildCommitArgs } from './_git-author'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-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}`)
+forwardLegacyCtorTool('deploy', import.meta.url)

package/tools/mcp-server.ts

@@ -1,28 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-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'
-
-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)
+forwardLegacyCtorTool('mcp', import.meta.url)

package/tools/postinstall.ts

@@ -1,235 +1,4 @@
-import {
-  cp,
-  lstat,
-  mkdir,
-  readFile,
-  readdir,
-  readlink,
-  rm,
-  stat,
-  symlink,
-  writeFile,
-} from 'fs/promises'
-import * as path from 'path'
-import TOML from '@iarna/toml'
+#!/usr/bin/env bun
+import { forwardLegacyCtorTool } from './_forward.ts'
 
-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
+forwardLegacyCtorTool('postinstall', import.meta.url)