@fugood/bricks-project 2.25.0-beta.15 → 2.25.0-beta.16

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.25.0-beta.15",
+  "version": "2.25.0-beta.16",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.15",
+    "@fugood/bricks-cli": "^2.25.0-beta.16",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",

package/package.json.bak

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.15",
+  "version": "2.25.0-beta.16",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.15",
+    "@fugood/bricks-cli": "^2.25.0-beta.16",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",

package/tools/_git-author.ts

@@ -15,7 +15,15 @@ async function hasGitIdentity(cwd: string): Promise<boolean> {
 // 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[]> {
+//
+// `extraFlags` are inserted between `commit` and the `-m` args (e.g.
+// `['--no-verify']` to bypass pre-commit hooks for controlled cases like
+// committing merge-conflict markers).
+export async function buildCommitArgs(
+  cwd: string,
+  messages: string[],
+  extraFlags: string[] = [],
+): Promise<string[]> {
   const hasIdentity = await hasGitIdentity(cwd)
   const prefix = hasIdentity
     ? []
@@ -23,7 +31,7 @@ export async function buildCommitArgs(cwd: string, messages: string[]): Promise<
   const msgArgs: string[] = []
   for (const m of messages) msgArgs.push('-m', m)
   if (hasIdentity) msgArgs.push('-m', CTOR_COAUTHOR_TRAILER)
-  return [...prefix, 'commit', ...msgArgs]
+  return [...prefix, 'commit', ...extraFlags, ...msgArgs]
 }
 
 export { CTOR_NAME, CTOR_EMAIL, CTOR_COAUTHOR_TRAILER }

package/tools/_last-pushed-commit.ts

@@ -0,0 +1,28 @@
+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 update-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/deploy.ts

@@ -2,6 +2,7 @@ import { access, readFile, writeFile } from 'node:fs/promises'
 import { parseArgs } from 'util'
 import { sh } from './_shell'
 import { buildCommitArgs } from './_git-author'
+import { writeLastPushedCommit } from './_last-pushed-commit'
 
 if (!process.env.BRICKS_RELEASE_SIGN) {
   process.env.BRICKS_RELEASE_SIGN = 'CTOR'
@@ -170,4 +171,10 @@ if (result.exitCode !== 0) {
 }
 
 const output = JSON.parse(result.stdout.toString())
+
+// Record the commit we just pushed from so a later pull can use it as the
+// merge base regardless of what the server stores in
+// bricks_project_last_commit_id.
+if (commitId) await writeLastPushedCommit(cwd, commitId)
+
 console.log(`${isModule ? 'Module' : 'App'} deployed: ${output.name}`)

package/tools/pull.ts

@@ -4,6 +4,7 @@ import { join, relative } from 'node:path'
 import { format } from 'oxfmt'
 import { sh } from './_shell'
 import { buildCommitArgs } from './_git-author'
+import { readLastPushedCommit, writeLastPushedCommit } from './_last-pushed-commit'
 
 // Directories whose .ts contents are entirely owned by the generator.
 // Anything under these dirs not present in the freshly pulled file list is an orphan.
@@ -75,30 +76,40 @@ if (result.exitCode !== 0) {
   }
 }
 
-const { files, lastCommitId } = JSON.parse(result.stdout.toString())
+const { files, lastCommitId: serverLastCommitId } = JSON.parse(result.stdout.toString())
+
+// The locally-saved commit (recorded by deploy/update-config) is the
+// authoritative merge base for THIS clone — the server's value can be an
+// opaque nanoid (config-only updates) or point to a commit other clients
+// produced. Fall back to the server's value only if we have no local
+// record yet.
+const savedLocalCommitId = await readLastPushedCommit(cwd)
+const baseCommitId = savedLocalCommitId || serverLastCommitId
+
+const branchName = isModule
+  ? 'BRICKS_PROJECT_try-pull-module'
+  : 'BRICKS_PROJECT_try-pull-application'
 
-let useMain = false
 if (isGitRepo && !force) {
-  console.log(`Checking commit ${lastCommitId}...`)
-  const found = (await sh`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
+  console.log(`Checking commit ${baseCommitId}...`)
+  const found = (await sh`cd ${cwd} && git rev-list -1 ${baseCommitId}`.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 headCommitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
 
-  const branchName = isModule
-    ? 'BRICKS_PROJECT_try-pull-module'
-    : 'BRICKS_PROJECT_try-pull-application'
+  if (headCommitId === serverLastCommitId) throw new Error('Commit not changed')
 
   await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
 
+  // When the base commit isn't reachable in this clone (server stored a
+  // nanoid, or the commit was pruned), fall back to forking from current
+  // HEAD. The downstream merge into main collapses both paths into the
+  // same result, just with different merge bases.
   if (found) {
-    await sh`cd ${cwd} && git checkout -b ${branchName} ${lastCommitId}`.nothrow()
+    await sh`cd ${cwd} && git checkout -b ${branchName} ${baseCommitId}`.nothrow()
   } else {
     await sh`cd ${cwd} && git checkout -b ${branchName}`
-    useMain = true
   }
 }
 
@@ -152,9 +163,33 @@ if (isGitRepo) {
     const commitArgs = await buildCommitArgs(cwd, [commitMsg])
     await sh`cd ${cwd} && git ${commitArgs}`
   }
-  if (!force && !useMain) {
-    await sh`cd ${cwd} && git merge main`
+  if (!force) {
+    // Land the pulled commits on main with a single 3-way merge using
+    // baseCommit as the merge base. The user doesn't have to manage a side
+    // branch, and conflicts (if any) land in the working tree on main where
+    // auto-compile surfaces them as typecheck errors to resolve in-place.
+    await sh`cd ${cwd} && git checkout main`
+    const mergeResult = await sh`cd ${cwd} && git merge ${branchName} --no-edit`.nothrow()
+    if (mergeResult.exitCode !== 0) {
+      // Conflict markers are in the working tree — commit them so the tree
+      // is clean for auto-compile to detect, leaving the resolution to the
+      // user. Pre-commit hooks would reject markers (lint/format fail on
+      // invalid syntax), so bypass them for this controlled case.
+      await sh`cd ${cwd} && git add .`
+      const conflictArgs = await buildCommitArgs(
+        cwd,
+        ['chore(project): merge with conflicts (resolve in main)'],
+        ['--no-verify'],
+      )
+      await sh`cd ${cwd} && git ${conflictArgs}`
+    }
+    // The try-pull branch served its purpose; delete it so `git branch`
+    // stays tidy. The next pull recreates it anyway (line 103).
+    await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
   }
+  // Record the new sync point so a follow-up pull starts from the right base.
+  const newHead = (await sh`cd ${cwd} && git rev-parse HEAD`.nothrow().text()).trim()
+  if (newHead) await writeLastPushedCommit(cwd, newHead)
 }
 
 console.log(

package/tools/update-config.ts

@@ -2,6 +2,7 @@ import { readFile, writeFile } from 'node:fs/promises'
 import { parseArgs } from 'util'
 import { sh } from './_shell'
 import { buildCommitArgs } from './_git-author'
+import { writeLastPushedCommit } from './_last-pushed-commit'
 
 const cwd = process.cwd()
 
@@ -107,4 +108,11 @@ if (result.exitCode !== 0) {
 }
 
 const output = JSON.parse(result.stdout.toString())
+
+// Record the commit we just pushed from so a later pull can use it as the
+// merge base regardless of what the server stores in
+// bricks_project_last_commit_id (which may be an opaque nanoid for
+// content-only edits).
+if (commitId) await writeLastPushedCommit(cwd, commitId)
+
 console.log(`${isModule ? 'Module' : 'App'} config updated: ${output.target?.name || app.name}`)