@cellajs/cli 0.0.3 → 0.0.4

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env tsx
 
 // src/cella-cli.ts
-import { existsSync as existsSync9, statSync as statSync2 } from "fs";
-import { join as join16, resolve as resolve5 } from "path";
+import { existsSync as existsSync10, statSync as statSync2 } from "fs";
+import { join as join17, resolve as resolve5 } from "path";
 import process9 from "process";
 
 // src/cli.ts
 import { readFileSync } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import process5 from "process";
 import { select } from "@inquirer/prompts";
 import { Command } from "commander";
@@ -53,8 +53,8 @@ var pc = {
 var colors_default = pc;
 
 // src/utils/config.ts
-import { existsSync, realpathSync } from "fs";
-import { join, resolve } from "path";
+import { existsSync as existsSync2, realpathSync } from "fs";
+import { join as join2, resolve } from "path";
 import { z as z2 } from "zod";
 
 // src/config/types.ts
@@ -96,9 +96,11 @@ var cellaConfigSchema = z.object({
 }).strict();
 
 // src/utils/module-territory.ts
-import { relative, sep } from "path";
+import { existsSync } from "fs";
+import { basename, join, relative, sep } from "path";
 import { Project, SyntaxKind } from "ts-morph";
 var MODULE_FILE_GLOBS = ["backend/src/modules/*/*-module.ts", "frontend/src/modules/*/*-module.ts"];
+var FRONTEND_STATIC_ROOT = "frontend/public/static";
 function readOwner(call) {
   const arg = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
   const initializer = arg?.getProperty("owner")?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
@@ -112,11 +114,19 @@ function resolveAppModuleFolders(repoPath) {
   });
   const sourceFiles = project.addSourceFilesAtPaths(MODULE_FILE_GLOBS.map((glob) => `${repoPath}/${glob}`));
   const folders = /* @__PURE__ */ new Set();
+  const moduleNames = /* @__PURE__ */ new Set();
   for (const sourceFile of sourceFiles) {
     const ownsApp = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => call.getExpression().getText() === "registerModule" && readOwner(call) === "app");
     if (!ownsApp) continue;
     const folder = relative(repoPath, sourceFile.getDirectoryPath()).split(sep).join("/");
     folders.add(folder);
+    moduleNames.add(basename(folder));
+  }
+  for (const moduleName of moduleNames) {
+    const staticFolder = `${FRONTEND_STATIC_ROOT}/${moduleName}`;
+    if (existsSync(join(repoPath, staticFolder))) {
+      folders.add(staticFolder);
+    }
   }
   return [...folders];
 }
@@ -145,8 +155,8 @@ function resolveUpstream(settings) {
   return { track, branchRef };
 }
 async function loadConfig(forkPath) {
-  const configPath = join(forkPath, "cella.config.ts");
-  if (!existsSync(configPath)) {
+  const configPath = join2(forkPath, "cella.config.ts");
+  if (!existsSync2(configPath)) {
     throw new Error(`config file not found: ${configPath}`);
   }
   const realConfigPath = realpathSync(configPath);
@@ -180,13 +190,13 @@ ${z2.prettifyError(result.error)}`);
 
 // src/utils/display.ts
 import { writeFileSync } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { join as join3, resolve as resolve2 } from "path";
 import process4 from "process";
 
 // package.json
 var package_default = {
   name: "@cellajs/cli",
-  version: "0.0.3",
+  version: "0.0.4",
   private: false,
   license: "MIT",
   description: "CLI for managing your monorepo and syncing with upstream Cella.",
@@ -505,7 +515,7 @@ var summaryStatusConfig = {
     icon: colors_default.cyan("\u25C7"),
     label: "managed",
     color: colors_default.cyan,
-    description: "package/config files handled separately"
+    description: "package.jsons & cella.config.ts handled separately"
   },
   ignored: { ...statusConfig.ignored, description: "protected by ignored config" }
 };
@@ -593,7 +603,7 @@ function printAnalysisFileGroups(files, linkOptions) {
   });
 }
 function writeLogFile(forkPath, files) {
-  const logPath = join2(forkPath, "cella-sync.log");
+  const logPath = join3(forkPath, "cella-sync.log");
   const lines = [
     `cella sync analysis - ${(/* @__PURE__ */ new Date()).toISOString()}`,
     DIVIDER,
@@ -651,8 +661,8 @@ function printFlagWarnings(options) {
 }
 
 // src/utils/overrides.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 function isUnderAnyFolder(filePath, folders) {
   return folders.some((folder) => {
     const entry = folder.replace(/\/+$/, "");
@@ -684,7 +694,7 @@ function validateOverrides(config, forkPath) {
         pattern: entry,
         message: `pin uses glob (not supported, use a path or folder): ${entry}`
       });
-    } else if (!existsSync2(join3(forkPath, entry))) {
+    } else if (!existsSync3(join4(forkPath, entry))) {
       warnings.push({
         type: "pinned-not-found",
         pattern: entry,
@@ -700,7 +710,7 @@ function validateOverrides(config, forkPath) {
         pattern: entry,
         message: `ignored entry uses glob (not supported, use a path or folder): ${entry}`
       });
-    } else if (!existsSync2(join3(forkPath, entry.replace(/\/+$/, "")))) {
+    } else if (!existsSync3(join4(forkPath, entry.replace(/\/+$/, "")))) {
       warnings.push({
         type: "ignored-not-found",
         pattern: entry,
@@ -810,7 +820,7 @@ var serviceDefinitions = [
 async function getMenuContext(userConfig, forkPath) {
   return {
     hasForks: (userConfig.forks?.length ?? 0) > 0,
-    isUpstreamRepo: JSON.parse(readFileSync(join4(forkPath, "package.json"), "utf8")).name === "cella"
+    isUpstreamRepo: JSON.parse(readFileSync(join5(forkPath, "package.json"), "utf8")).name === "cella"
   };
 }
 function buildServiceChoices(context) {
@@ -909,13 +919,13 @@ async function parseCli(userConfig, forkPath) {
 }
 
 // src/services/analyze.ts
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 
 // src/utils/diff.ts
 import { execFileSync } from "child_process";
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { basename, join as join5 } from "path";
+import { basename as basename2, join as join6 } from "path";
 import process6 from "process";
 function gitDiffFile(cwd, range, filePath, options = {}) {
   const args = ["diff", "--no-color"];
@@ -1009,34 +1019,34 @@ function openWithDefaultApp(target) {
 }
 async function openDiffInBrowser(patch, meta, repoPath) {
   const html = await renderDiffPage(patch, meta);
-  const dir = join5(tmpdir(), `cella-diff-${basename(repoPath)}`);
+  const dir = join6(tmpdir(), `cella-diff-${basename2(repoPath)}`);
   mkdirSync(dir, { recursive: true });
-  const outPath = join5(dir, `${meta.filePath.replace(/[^\w.-]+/g, "-")}.html`);
+  const outPath = join6(dir, `${meta.filePath.replace(/[^\w.-]+/g, "-")}.html`);
   writeFileSync2(outPath, html);
   openWithDefaultApp(outPath);
   return outPath;
 }
 
 // src/utils/cleanup.ts
-import { existsSync as existsSync4, rmSync } from "fs";
+import { existsSync as existsSync5, rmSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename2, join as join8 } from "path";
+import { basename as basename3, join as join9 } from "path";
 import process7 from "process";
 
 // src/utils/git.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { mkdir, readdir, rmdir, unlink } from "fs/promises";
-import { dirname, join as join7 } from "path";
+import { dirname, join as join8 } from "path";
 import { promisify } from "util";
 
 // src/utils/manifest.ts
 import { readFile, writeFile } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var MANIFEST_FILE = "cella.manifest.json";
 async function readSyncManifest(cwd) {
   try {
-    const parsed = JSON.parse(await readFile(join6(cwd, MANIFEST_FILE), "utf8"));
+    const parsed = JSON.parse(await readFile(join7(cwd, MANIFEST_FILE), "utf8"));
     const commit = parsed?.upstream?.commit;
     if (typeof commit !== "string" || !/^[0-9a-f]{40}$/i.test(commit)) return null;
     return parsed;
@@ -1049,7 +1059,7 @@ async function readManifestBase(cwd) {
   return manifest ? manifest.upstream.commit.toLowerCase() : null;
 }
 async function writeSyncManifest(cwd, manifest) {
-  await writeFile(join6(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  await writeFile(join7(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 
@@ -1120,8 +1130,8 @@ async function flattenBranch(cwd, baseRef, message) {
 }
 async function commitSquash(cwd, message) {
   for (const file of ["MERGE_HEAD", "MERGE_MSG", "MERGE_MODE"]) {
-    const path4 = join7(cwd, ".git", file);
-    if (existsSync3(path4)) await unlink(path4);
+    const path4 = join8(cwd, ".git", file);
+    if (existsSync4(path4)) await unlink(path4);
   }
   await git(["commit", "-m", message], cwd, { skipEditor: true });
 }
@@ -1129,7 +1139,7 @@ async function stageAll(cwd) {
   await git(["add", "-A"], cwd);
 }
 function mergeInProgress(cwd) {
-  return existsSync3(join7(cwd, ".git", "MERGE_HEAD"));
+  return existsSync4(join8(cwd, ".git", "MERGE_HEAD"));
 }
 async function getShortSha(cwd, ref) {
   return git(["rev-parse", "--short", ref], cwd);
@@ -1359,15 +1369,15 @@ async function batchUnstageFiles(cwd, filePaths) {
   await git(["rm", "--cached", "-f", "--", ...filePaths], cwd, { ignoreErrors: true });
 }
 async function gitMv(cwd, oldPath, newPath) {
-  const newDir = dirname(join7(cwd, newPath));
+  const newDir = dirname(join8(cwd, newPath));
   await mkdir(newDir, { recursive: true });
   await git(["mv", "-f", oldPath, newPath], cwd);
 }
 async function fileExistsInWorktree(cwd, filePath) {
-  return existsSync3(join7(cwd, filePath));
+  return existsSync4(join8(cwd, filePath));
 }
 async function removeFileFromWorktree(cwd, filePath) {
-  const fullPath = join7(cwd, filePath);
+  const fullPath = join8(cwd, filePath);
   try {
     await unlink(fullPath);
     await cleanupEmptyParentDirs(cwd, dirname(filePath));
@@ -1380,7 +1390,7 @@ async function removeFileFully(cwd, filePath) {
 }
 async function cleanupEmptyParentDirs(cwd, relativePath) {
   if (!relativePath || relativePath === ".") return;
-  const fullPath = join7(cwd, relativePath);
+  const fullPath = join8(cwd, relativePath);
   try {
     const entries = await readdir(fullPath);
     if (entries.length === 0) {
@@ -1408,14 +1418,28 @@ async function getStoredSyncHead(cwd) {
   const ref = await git(["rev-parse", "refs/cella/last-sync-head"], cwd, { ignoreErrors: true });
   return ref || null;
 }
-async function readManifestBaseAtRef(cwd, ref) {
+async function readManifestAtRef(cwd, ref) {
   const raw = await git(["show", `${ref}:${MANIFEST_FILE}`], cwd, { ignoreErrors: true });
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
     const commit = parsed?.upstream?.commit;
     if (typeof commit !== "string" || !/^[0-9a-f]{40}$/i.test(commit)) return null;
-    return commit.toLowerCase();
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function readManifestBaseAtRef(cwd, ref) {
+  const manifest = await readManifestAtRef(cwd, ref);
+  return manifest ? manifest.upstream.commit.toLowerCase() : null;
+}
+async function readPackageVersionAtRef(cwd, ref) {
+  const raw = await git(["show", `${ref}:package.json`], cwd, { ignoreErrors: true });
+  if (!raw) return null;
+  try {
+    const version = JSON.parse(raw).version;
+    return typeof version === "string" && version ? version : null;
   } catch {
     return null;
   }
@@ -1433,28 +1457,82 @@ async function getRootCommit(cwd, ref) {
   const roots = out.split("\n").filter(Boolean);
   return roots.length > 0 ? roots[roots.length - 1] : null;
 }
+var SCAFFOLD_CANDIDATE_LIMIT = 400;
+var SCAFFOLD_SCORE_CONCURRENCY = 10;
+var SCAFFOLD_MATCH_MAX_DIFF_RATIO = 0.3;
+async function inferScaffoldBase(cwd, headRef, upstreamRef) {
+  const root = await getRootCommit(cwd, headRef);
+  if (!root) return null;
+  const rootDate = await git(["show", "-s", "--format=%cI", root], cwd, { ignoreErrors: true });
+  if (!rootDate) return null;
+  const before = new Date(new Date(rootDate).getTime() + 24 * 60 * 60 * 1e3).toISOString();
+  const revList = await git(
+    ["rev-list", `--max-count=${SCAFFOLD_CANDIDATE_LIMIT}`, `--before=${before}`, upstreamRef],
+    cwd,
+    { ignoreErrors: true }
+  );
+  const candidates = revList.split("\n").filter(Boolean);
+  if (candidates.length === 0) return null;
+  const totalPaths = (await git(["ls-tree", "-r", "--name-only", root], cwd)).split("\n").filter(Boolean).length;
+  if (totalPaths === 0) return null;
+  let best = null;
+  outer: for (let i = 0; i < candidates.length; i += SCAFFOLD_SCORE_CONCURRENCY) {
+    const chunk = candidates.slice(i, i + SCAFFOLD_SCORE_CONCURRENCY);
+    const scores = await Promise.all(
+      chunk.map(async (sha) => {
+        try {
+          const out = await git(["diff-tree", "-r", "--name-only", sha, root], cwd);
+          return { sha, diff: out ? out.split("\n").length : 0 };
+        } catch {
+          return { sha, diff: Number.POSITIVE_INFINITY };
+        }
+      })
+    );
+    for (const score of scores) {
+      if (!best || score.diff < best.diff) best = score;
+      if (best.diff === 0) break outer;
+    }
+  }
+  if (!best || best.diff / totalPaths > SCAFFOLD_MATCH_MAX_DIFF_RATIO) return null;
+  return best.sha;
+}
+async function readRootTrailerBase(cwd, headRef) {
+  const root = await getRootCommit(cwd, headRef);
+  if (!root) return null;
+  const message = await git(["show", "-s", "--format=%B", root], cwd, { ignoreErrors: true });
+  const match = message.match(/^cella-base:\s*([0-9a-f]{40})$/im);
+  return match ? match[1].toLowerCase() : null;
+}
 async function ensureSyncBase(cwd, headRef, upstreamRef) {
   const nativeBase = await git(["merge-base", headRef, upstreamRef], cwd, { ignoreErrors: true });
   if (nativeBase) return;
-  const baseSha = await getStoredSyncRef(cwd) ?? await readManifestBaseAtRef(cwd, headRef) ?? await readManifestBase(cwd);
+  const sources = [
+    () => getStoredSyncRef(cwd),
+    () => readManifestBaseAtRef(cwd, headRef),
+    () => readManifestBase(cwd),
+    () => readRootTrailerBase(cwd, headRef),
+    () => inferScaffoldBase(cwd, headRef, upstreamRef)
+  ];
+  let baseSha = null;
+  for (const source of sources) {
+    const sha = await source();
+    if (sha && await commitObjectExists(cwd, sha)) {
+      baseSha = sha;
+      break;
+    }
+  }
   if (!baseSha) {
     throw new Error(
-      `no common ancestor between the fork and '${upstreamRef}', and no sync base recorded.
+      `no common ancestor between the fork and '${upstreamRef}', and no sync base could be determined.
 
 This fork has unrelated history with upstream \u2014 typical for a create-cella scaffold, or after
-upstream squashed its history. Seed the base with the upstream commit the fork was created from,
-then re-run sync:
+upstream squashed its history \u2014 and no recorded or inferable base commit exists after fetching
+upstream. Seed it manually with the upstream commit the fork was created from, then re-run sync:
 
   git update-ref refs/cella/last-sync <upstream-sha>
 `
     );
   }
-  if (!await commitObjectExists(cwd, baseSha)) {
-    throw new Error(
-      `recorded sync base ${baseSha.slice(0, 12)} is not present after fetching '${upstreamRef}'.
-It may belong to a different upstream, or have been dropped by an upstream history rewrite.`
-    );
-  }
   const root = await getRootCommit(cwd, headRef);
   if (!root) throw new Error("could not determine the fork's root commit to bootstrap sync ancestry");
   await git(["replace", "-f", "--graft", root, baseSha], cwd);
@@ -1497,7 +1575,7 @@ var WORKTREE_PREFIXES = {
   view: "cella-view-"
 };
 function buildWorktreePath(kind, repoPath) {
-  return join8(tmpdir2(), `${WORKTREE_PREFIXES[kind]}${basename2(repoPath)}`);
+  return join9(tmpdir2(), `${WORKTREE_PREFIXES[kind]}${basename3(repoPath)}`);
 }
 function getWorktreePath(repoPath) {
   return buildWorktreePath("sync", repoPath);
@@ -1515,7 +1593,7 @@ function unregisterWorktree() {
 }
 async function cleanupWorktree(repoPath, worktreePath) {
   await removeWorktree(repoPath, worktreePath);
-  if (existsSync4(worktreePath)) {
+  if (existsSync5(worktreePath)) {
     rmSync(worktreePath, { recursive: true, force: true });
   }
   unregisterWorktree();
@@ -1523,14 +1601,14 @@ async function cleanupWorktree(repoPath, worktreePath) {
 async function cleanupLeftoverWorktrees(repoPath) {
   for (const kind of Object.keys(WORKTREE_PREFIXES)) {
     const worktreePath = buildWorktreePath(kind, repoPath);
-    if (existsSync4(worktreePath)) {
+    if (existsSync5(worktreePath)) {
       await cleanupWorktree(repoPath, worktreePath);
     }
   }
   const prefixes = Object.values(WORKTREE_PREFIXES);
   const worktrees = await listWorktrees(repoPath);
   for (const wt of worktrees) {
-    if (prefixes.some((prefix) => wt.includes(prefix)) && !existsSync4(wt)) {
+    if (prefixes.some((prefix) => wt.includes(prefix)) && !existsSync5(wt)) {
       await removeWorktree(repoPath, wt);
     }
   }
@@ -2073,7 +2151,7 @@ function findTargetFile(files, targetPath) {
 }
 function printUnifiedDiff(config, filePath) {
   const diff = gitDiffFile(config.forkPath, `${config.upstreamRef}..HEAD`, filePath, {
-    dstPrefix: basename3(config.forkPath)
+    dstPrefix: basename4(config.forkPath)
   });
   writeStdout(diff.toString());
 }
@@ -2128,7 +2206,7 @@ async function runAnalyze(config) {
       {
         filePath: file.path,
         srcLabel: "cella",
-        dstLabel: basename3(config.forkPath),
+        dstLabel: basename4(config.forkPath),
         note: "local working tree"
       },
       config.forkPath
@@ -2923,7 +3001,7 @@ async function checkOverrides(forkPath) {
 
 // src/services/contributions.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import {
   createPrompt,
   isDownKey,
@@ -2938,7 +3016,7 @@ import {
 import { select as select2 } from "@inquirer/prompts";
 
 // src/services/contrib-core.ts
-import { dirname as dirname2, join as join11 } from "path";
+import { dirname as dirname2, join as join12 } from "path";
 async function listFilesAtRef(repoPath, ref) {
   const raw = await git(["ls-tree", "-r", "--name-only", ref], repoPath);
   return new Set(raw.split("\n").filter(Boolean));
@@ -3000,7 +3078,7 @@ async function readBlobInfo(repoPath, ref, filePath) {
 }
 async function buildContribBranch(repoPath, baseRef, forkRef, detection, forkName) {
   const branch = `contrib/${forkName}`;
-  const tmpIndex = join11(repoPath, ".git", `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
+  const tmpIndex = join12(repoPath, ".git", `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
   const indexEnv = { GIT_INDEX_FILE: tmpIndex };
   try {
     await git(["read-tree", baseRef], repoPath, { env: indexEnv });
@@ -3043,16 +3121,16 @@ ${commitBody}`;
 }
 
 // src/services/fork-utils.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve3 } from "path";
 function validateForkPath(fork, basePath, requireConfig = false) {
   const resolvedPath = resolve3(basePath, fork.localPath);
   if (!resolvedPath.startsWith(resolve3(basePath, ".."))) {
     return { fork, resolvedPath, valid: false, error: "path resolves outside parent directory" };
   }
-  if (!existsSync6(resolvedPath)) return { fork, resolvedPath, valid: false, error: "path does not exist" };
-  if (!existsSync6(`${resolvedPath}/.git`)) return { fork, resolvedPath, valid: false, error: "not a git repository" };
-  if (requireConfig && !existsSync6(`${resolvedPath}/cella.config.ts`)) {
+  if (!existsSync7(resolvedPath)) return { fork, resolvedPath, valid: false, error: "path does not exist" };
+  if (!existsSync7(`${resolvedPath}/.git`)) return { fork, resolvedPath, valid: false, error: "not a git repository" };
+  if (requireConfig && !existsSync7(`${resolvedPath}/cella.config.ts`)) {
     return { fork, resolvedPath, valid: false, error: "missing cella.config.ts" };
   }
   return { fork, resolvedPath, valid: true };
@@ -3070,7 +3148,7 @@ async function showContribDiff(item, baseRef, cwd, forkName) {
   return openDiffInBrowser(patch.toString(), { filePath: item.path, srcLabel: "cella", dstLabel: forkName }, cwd);
 }
 function shouldApplyContributionsUnstaged(repoPath) {
-  return JSON.parse(readFileSync4(join12(repoPath, "package.json"), "utf8")).name === "cella";
+  return JSON.parse(readFileSync4(join13(repoPath, "package.json"), "utf8")).name === "cella";
 }
 var contribPrompt = createPrompt((config, done) => {
   const { pageSize = 20, baseRef, cwd, forkName } = config;
@@ -3417,11 +3495,6 @@ async function runContributions(config) {
     spinnerSuccess(`applied ${applied} files ${colors_default.dim(applyUnstaged ? "(unstaged)" : "(staged)")}`);
   }
   console.info();
-  console.info(`  ${colors_default.cyan(forkName)} ${colors_default.dim(`(${selected.length} files)`)}`);
-  for (const item of selected) {
-    console.info(`    ${colors_default.dim("\u2192")} ${item.deleted ? `(deleted) ${item.path}` : item.path}`);
-  }
-  console.info();
   console.info(
     colors_default.dim(
       applyUnstaged ? "  files are unstaged \u2014 review, stage what you want, and commit when ready" : "  files are staged \u2014 review and commit when ready"
@@ -3439,8 +3512,8 @@ import { Separator as Separator2, select as select3 } from "@inquirer/prompts";
 import { spawnSync as spawnSync2 } from "child_process";
 
 // src/services/packages.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join14 } from "path";
 function parseComparableVersion(version) {
   const trimmed = version.trim();
   if (trimmed === "" || trimmed === "*" || trimmed.includes("workspace:") || trimmed.includes("catalog:") || trimmed.includes("file:") || trimmed.includes("link:") || trimmed.includes("git+") || trimmed.includes("github:") || trimmed.includes("http://") || trimmed.includes("https://") || trimmed.includes("||")) {
@@ -3544,7 +3617,7 @@ function safeMergePnpm(forkPnpm, upstreamPnpm) {
   return { merged, changed };
 }
 function readPackageJson(filePath) {
-  if (!existsSync7(filePath)) return null;
+  if (!existsSync8(filePath)) return null;
   try {
     return JSON.parse(readFileSync5(filePath, "utf-8"));
   } catch {
@@ -3566,11 +3639,11 @@ async function getUpstreamPackageJson(forkPath, upstreamRef, relativePath) {
 async function discoverPackageLocations(forkPath, upstreamRef) {
   const stdout = await git(["ls-tree", "-r", "--name-only", upstreamRef], forkPath, { ignoreErrors: true });
   const upstreamPaths = stdout.split("\n").filter((p) => p.endsWith("/package.json") || p === "package.json").map((p) => p === "package.json" ? "" : p.replace("/package.json", ""));
-  return upstreamPaths.filter((loc) => existsSync7(join13(forkPath, loc, "package.json")));
+  return upstreamPaths.filter((loc) => existsSync8(join14(forkPath, loc, "package.json")));
 }
 async function syncPackageJson(forkPath, upstreamRef, relativePath, keysToSync) {
   const changes = [];
-  const pkgPath = join13(forkPath, relativePath, "package.json");
+  const pkgPath = join14(forkPath, relativePath, "package.json");
   const forkPkg = readPackageJson(pkgPath);
   const upstreamPkg = await getUpstreamPackageJson(forkPath, upstreamRef, relativePath);
   if (!forkPkg || !upstreamPkg) {
@@ -3718,12 +3791,57 @@ async function runSync(config, options) {
   return result;
 }
 var SYNC_PR_TITLE = "chore: sync upstream cella";
-function printPrCreateStep(branch, base) {
-  console.info(colors_default.dim(`  gh pr create --base ${base} --head ${branch} --title "${SYNC_PR_TITLE}" --fill`));
+var PR_BODY_COMMIT_MAX = 50;
+async function buildSyncCommitMessage(forkPath, upstreamRef) {
+  const shortSha = await getShortSha(forkPath, upstreamRef).catch(() => "");
+  if (!shortSha) return SYNC_PR_TITLE;
+  const manifest = await readSyncManifest(forkPath);
+  const version = manifest?.upstream.release ?? await readPackageVersionAtRef(forkPath, upstreamRef).catch(() => null);
+  return version ? `${SYNC_PR_TITLE} v${version.replace(/^v/, "")} (${shortSha})` : `${SYNC_PR_TITLE} ${shortSha}`;
+}
+function qualifyPrRefs(subject, repoSlug) {
+  if (!repoSlug) return subject;
+  return subject.replace(/(^|[^\w/])#(\d+)\b/g, `$1${repoSlug}#$2`);
+}
+function buildSyncPrBody(input) {
+  const { repoSlug, version, fromSha, toSha, commits, totalCount } = input;
+  const githubUrl = repoSlug ? `https://github.com/${repoSlug}` : void 0;
+  const short = (sha) => sha.slice(0, 7);
+  const commitRef = (sha) => githubUrl ? `[\`${short(sha)}\`](${githubUrl}/commit/${sha})` : `\`${short(sha)}\``;
+  const upstreamName = githubUrl ? `[${repoSlug}](${githubUrl})` : "cella";
+  const versionSuffix = version ? ` (v${version.replace(/^v/, "")})` : "";
+  const lines = [`Syncs upstream ${upstreamName} to ${commitRef(toSha)}${versionSuffix}.`];
+  if (totalCount > 0 && fromSha) {
+    const compare = githubUrl ? ` ([compare](${githubUrl}/compare/${short(fromSha)}...${short(toSha)}))` : "";
+    lines.push("", `**${totalCount} upstream commit${totalCount === 1 ? "" : "s"} since last sync**${compare}:`, "");
+    if (totalCount > commits.length) lines.push(`- \u2026${totalCount - commits.length} earlier commit(s) not shown`);
+    for (const commit of commits) {
+      lines.push(`- ${commitRef(commit.hash)} ${qualifyPrRefs(commit.message, repoSlug)}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function buildSyncPrBodyForBranch(forkPath, base) {
+  const manifest = await readManifestAtRef(forkPath, "HEAD");
+  if (!manifest) return void 0;
+  const toSha = manifest.upstream.commit.toLowerCase();
+  const fromSha = await readManifestBaseAtRef(forkPath, base) ?? await getMergeBase(forkPath, base, toSha).catch(() => null);
+  const version = manifest.upstream.release ?? await readPackageVersionAtRef(forkPath, toSha).catch(() => null);
+  const totalCount = fromSha ? await countCommitsBetween(forkPath, fromSha, toSha).catch(() => 0) : 0;
+  const commits = fromSha && totalCount > 0 ? await listCommitsBetween(forkPath, fromSha, toSha, {
+    oldestFirst: true,
+    skip: totalCount > PR_BODY_COMMIT_MAX ? totalCount - PR_BODY_COMMIT_MAX : 0,
+    limit: PR_BODY_COMMIT_MAX
+  }) : [];
+  return buildSyncPrBody({ repoSlug: manifest.upstream.repo, version, fromSha, toSha, commits, totalCount });
+}
+function printPrCreateStep(branch, base, title = SYNC_PR_TITLE) {
+  console.info(colors_default.dim(`  gh pr create --base ${base} --head ${branch} --title "${title}" --fill`));
 }
-function printShipSteps(temporaryBranch, base) {
+function printShipSteps(temporaryBranch, base, title) {
   console.info(colors_default.dim(`  git push -u origin ${temporaryBranch}`));
-  printPrCreateStep(temporaryBranch, base);
+  printPrCreateStep(temporaryBranch, base, title);
 }
 function printFinishSteps() {
   console.info(colors_default.dim("  pnpm cella sync"));
@@ -3740,8 +3858,7 @@ function extractFirstUrl(output) {
 async function flattenSyncBranch(forkPath, branch, base) {
   const mergeCommits = await listBranchMergeCommits(forkPath, base);
   if (mergeCommits.length === 0) return false;
-  const upstreamSha = await getShortSha(forkPath, `${mergeCommits[0]}^2`).catch(() => "");
-  const message = upstreamSha ? `${SYNC_PR_TITLE} ${upstreamSha}` : SYNC_PR_TITLE;
+  const message = await buildSyncCommitMessage(forkPath, `${mergeCommits[0]}^2`);
   console.info(
     colors_default.yellow(
       `'${branch}' contains ${mergeCommits.length} merge commit(s) \u2014 the PR would list the entire upstream history.`
@@ -3757,18 +3874,22 @@ async function shipSyncBranch(config, branch) {
   const flattened = await flattenSyncBranch(forkPath, branch, base);
   let prUrl;
   let prOpened = false;
+  const headSubject = (await getCommitInfo(forkPath, "HEAD").catch(() => null))?.message;
+  const prTitle = headSubject?.startsWith(SYNC_PR_TITLE) ? headSubject : SYNC_PR_TITLE;
   console.info(colors_default.dim(`pushing '${branch}' to origin...`));
   try {
     await pushBranch(forkPath, "origin", branch, { forceWithLease: flattened });
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     console.info(colors_default.yellow(`push failed (${detail.split("\n")[0]}). finish manually:`));
-    printShipSteps(branch, base);
+    printShipSteps(branch, base, prTitle);
     return;
   }
   if (ghAvailable()) {
     console.info(colors_default.dim("opening a pull request..."));
-    const pr = spawnSync2("gh", ["pr", "create", "--base", base, "--head", branch, "--title", SYNC_PR_TITLE, "--fill"], {
+    const prBody = await buildSyncPrBodyForBranch(forkPath, base);
+    const bodyArgs = prBody ? ["--body", prBody] : ["--fill"];
+    const pr = spawnSync2("gh", ["pr", "create", "--base", base, "--head", branch, "--title", prTitle, ...bodyArgs], {
       cwd: forkPath,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -3779,11 +3900,11 @@ ${pr.stderr ?? ""}`);
     if (!prOpened) {
       console.info(colors_default.yellow("could not open the PR automatically (it may already exist). open it with:"));
       if (prUrl) console.info(colors_default.dim(`  ${prUrl}`));
-      printPrCreateStep(branch, base);
+      printPrCreateStep(branch, base, prTitle);
     }
   } else {
     console.info(colors_default.yellow("`gh` not found \u2014 open the PR manually:"));
-    printPrCreateStep(branch, base);
+    printPrCreateStep(branch, base, prTitle);
   }
   console.info(colors_default.dim(`switching back to '${base}'...`));
   await switchBranch(forkPath, base);
@@ -3839,9 +3960,8 @@ async function resumeSyncMerge(config, branch) {
     );
     return;
   }
-  const upstreamSha = await getShortSha(forkPath, "MERGE_HEAD").catch(() => "");
+  const message = await buildSyncCommitMessage(forkPath, "MERGE_HEAD");
   await stageAll(forkPath);
-  const message = upstreamSha ? `${SYNC_PR_TITLE} ${upstreamSha}` : SYNC_PR_TITLE;
   await commitSquash(forkPath, message);
   console.info();
   console.info(colors_default.green(`committed the sync on '${branch}' as '${message}'.`));
@@ -3999,7 +4119,7 @@ async function runForks(config) {
 
 // src/services/stats.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/utils/coverage-utils.ts
 import { spawnSync as spawnSync3 } from "child_process";
@@ -4087,7 +4207,7 @@ function printCoverageSummary(forkPath, options = {}) {
 // src/services/stats.ts
 var sourceExtensions = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mjs", "cjs", "json", "jsonc", "css", "html"]);
 async function getWorkspacePackages(forkPath) {
-  const content = await readFile2(join15(forkPath, "pnpm-workspace.yaml"), "utf-8");
+  const content = await readFile2(join16(forkPath, "pnpm-workspace.yaml"), "utf-8");
   return parseYamlBlockList(content, "packages").map((pattern) => {
     if (pattern.endsWith("/*")) {
       const base = pattern.slice(0, -2);
@@ -4245,7 +4365,7 @@ function getForkPath() {
   const envPath = getEnv("CELLA_FORK_PATH");
   if (envPath) {
     const resolved = resolve5(envPath);
-    if (!existsSync9(resolved) || !statSync2(resolved).isDirectory()) {
+    if (!existsSync10(resolved) || !statSync2(resolved).isDirectory()) {
       throw new Error(`CELLA_FORK_PATH is not a valid directory: ${resolved}`);
     }
     return resolved;
@@ -4257,7 +4377,7 @@ function getForkPath() {
   return cwd;
 }
 async function preflight(forkPath) {
-  if (!existsSync9(join16(forkPath, ".git"))) {
+  if (!existsSync10(join17(forkPath, ".git"))) {
     throw new Error(`not a git repository: ${forkPath}`);
   }
 }