@fugood/bricks-ctor 2.25.0-beta.60 → 2.25.0-beta.62

package/tools/_last-pushed-commit.ts

@@ -1,28 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-
-// Local sync marker: the git commit hash that was on HEAD when we last
-// successfully pushed to the server (deploy or push-config) or pulled
-// from it. Stored at the `.bricks/` top level (gitignored explicitly) — it's
-// per-clone state, not a build artifact, so it doesn't belong under
-// `.bricks/build/`.
-//
-// Why this exists: server's `bricks_project_last_commit_id` can be an opaque
-// nanoid for content-only edits (config-editor saves), so it isn't a
-// reliable git anchor for `git checkout` during pull. The local marker is
-// always a real reachable commit hash from THIS clone.
-const REL_PATH = '.bricks/.last-pushed-commit'
-
-export async function readLastPushedCommit(cwd: string): Promise<string | null> {
-  try {
-    const content = await readFile(`${cwd}/${REL_PATH}`, 'utf8')
-    return content.trim() || null
-  } catch {
-    return null
-  }
-}
-
-export async function writeLastPushedCommit(cwd: string, commitId: string): Promise<void> {
-  if (!commitId) return
-  await mkdir(`${cwd}/.bricks`, { recursive: true })
-  await writeFile(`${cwd}/${REL_PATH}`, commitId)
-}

package/tools/_mcp-config.ts

@@ -1,42 +0,0 @@
-import { readFile, writeFile, stat } from 'fs/promises'
-
-const exists = async (f: string) => {
-  try {
-    await stat(f)
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Refresh the `bricks-ctor` entry in a project's `.mcp.json` while preserving every other MCP
-// server the user configured. A malformed `.mcp.json` is left untouched (with a warning)
-// rather than overwritten with the default — clobbering it would silently delete the user's
-// other server entries. This mirrors `setupClaudeAutoMode`'s handling of a malformed
-// `settings.local.json` in postinstall.ts.
-export const handleMcpConfigOverride = async (mcpConfigPath: string, projectMcpServer: object) => {
-  let mcpConfig: { mcpServers: Record<string, unknown> }
-  if (await exists(mcpConfigPath)) {
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(await readFile(mcpConfigPath, 'utf-8'))
-    } catch {
-      console.warn(`Skipping .mcp.json update; ${mcpConfigPath} is not valid JSON`)
-      return
-    }
-    mcpConfig =
-      parsed && typeof parsed === 'object'
-        ? (parsed as { mcpServers: Record<string, unknown> })
-        : { mcpServers: {} }
-    if (!mcpConfig.mcpServers || typeof mcpConfig.mcpServers !== 'object') {
-      mcpConfig.mcpServers = {}
-    }
-    mcpConfig.mcpServers['bricks-ctor'] = projectMcpServer
-    delete mcpConfig.mcpServers['bricks-project']
-  } else {
-    mcpConfig = { mcpServers: { 'bricks-ctor': projectMcpServer } }
-  }
-
-  await writeFile(mcpConfigPath, `${JSON.stringify(mcpConfig, null, 2)}\n`)
-  console.log(`Updated ${mcpConfigPath}`)
-}

package/tools/_shell.ts

@@ -1,180 +0,0 @@
-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 _env: NodeJS.ProcessEnv | undefined
-  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
-  }
-
-  env(extra: NodeJS.ProcessEnv): this {
-    this._env = { ...this._env, ...extra }
-    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 env = this._env ? { ...process.env, ...this._env } : undefined
-    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio, env })
-
-    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/icons/.gitattributes

@@ -1 +0,0 @@
-* text=auto eol=lf