@cellajs/cli 0.0.5 → 0.1.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/cella-cli.ts
 import { existsSync as existsSync10, statSync as statSync2 } from "fs";
-import { join as join17, resolve as resolve5 } from "path";
+import { join as join17, resolve as resolve6 } from "path";
 import process9 from "process";
 
 // src/cli.ts
@@ -95,11 +95,25 @@ var cellaConfigSchema = z.object({
   ).optional()
 }).strict();
 
+// src/utils/managed-files.ts
+var CONFIG_FILE = "cella/cella.config.ts";
+function isPackageJson(filePath) {
+  return filePath === "package.json" || filePath.endsWith("/package.json");
+}
+function isManagedFile(filePath) {
+  return isPackageJson(filePath) || filePath === "pnpm-lock.yaml" || filePath === CONFIG_FILE;
+}
+
 // src/utils/module-territory.ts
 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 MODULE_FILE_GLOBS = [
+  "backend/src/modules/*/*-module.ts",
+  "frontend/src/modules/*/*-module.ts",
+  "frontend/src/modules/*/*-module.tsx"
+];
+var MODULE_REGISTER_CALLS = /* @__PURE__ */ new Set(["registerModule", "defineBackendModule", "defineFrontendModule"]);
 var FRONTEND_STATIC_ROOT = "frontend/public/static";
 function readOwner(call) {
   const arg = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
@@ -116,7 +130,7 @@ function resolveAppModuleFolders(repoPath) {
   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");
+    const ownsApp = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => MODULE_REGISTER_CALLS.has(call.getExpression().getText()) && readOwner(call) === "app");
     if (!ownsApp) continue;
     const folder = relative(repoPath, sourceFile.getDirectoryPath()).split(sep).join("/");
     folders.add(folder);
@@ -155,7 +169,7 @@ function resolveUpstream(settings) {
   return { track, branchRef };
 }
 async function loadConfig(forkPath) {
-  const configPath = join2(forkPath, "cella.config.ts");
+  const configPath = join2(forkPath, CONFIG_FILE);
   if (!existsSync2(configPath)) {
     throw new Error(`config file not found: ${configPath}`);
   }
@@ -196,7 +210,7 @@ import process4 from "process";
 // package.json
 var package_default = {
   name: "@cellajs/cli",
-  version: "0.0.5",
+  version: "0.1.0",
   private: false,
   license: "MIT",
   description: "CLI for managing your monorepo and syncing with upstream Cella.",
@@ -318,14 +332,6 @@ var package_default = {
   }
 };
 
-// src/utils/managed-files.ts
-function isPackageJson(filePath) {
-  return filePath === "package.json" || filePath.endsWith("/package.json");
-}
-function isManagedFile(filePath) {
-  return isPackageJson(filePath) || filePath === "pnpm-lock.yaml" || filePath === "cella.config.ts";
-}
-
 // src/utils/display.ts
 var NAME = "cella cli";
 var VERSION = package_default.version;
@@ -502,7 +508,7 @@ var statusConfig = {
   diverged: { icon: colors_default.magenta("\u21C5"), label: "diverged", color: colors_default.magenta, description: "both changed, will merge" },
   drifted: { icon: colors_default.yellow("!"), label: "drifted", color: colors_default.yellow, description: "fork changed (at risk)" },
   ahead: { icon: colors_default.blue("\u2191"), label: "ahead", color: colors_default.blue, description: "fork changed (protected)" },
-  local: { icon: colors_default.green("+"), label: "local", color: colors_default.green, description: "local file" },
+  local: { icon: colors_default.green("+"), label: "local", color: colors_default.green, description: "local file in cella folders" },
   pinned: { icon: colors_default.green("\u2A00"), label: "pinned", color: colors_default.green, description: "both changed, fork wins" },
   ignored: { icon: colors_default.gray("\u2A02"), label: "ignored", color: colors_default.gray },
   identical: { icon: colors_default.gray("\u2713"), label: "identical", color: colors_default.gray, description: "no changes" },
@@ -515,7 +521,7 @@ var summaryStatusConfig = {
     icon: colors_default.cyan("\u25C7"),
     label: "managed",
     color: colors_default.cyan,
-    description: "package.jsons & cella.config.ts handled separately"
+    description: "package.jsons & cella/cella.config.ts handled separately"
   },
   ignored: { ...statusConfig.ignored, description: "protected by ignored config" }
 };
@@ -585,7 +591,7 @@ function printAnalysisFileGroups(files, linkOptions) {
   });
   printFileGroup(files, "ahead", linkOptions, {
     title: `${colors_default.blue("\u2191 protected in fork")}`,
-    hint: "these files have fork changes and are protected by pinned or ignored config."
+    hint: "these files have fork changes but are protected (pinned)."
   });
   printFileGroup(files, "drifted", linkOptions, {
     title: `${warningMark} ${colors_default.yellow("drifted from upstream")}`,
@@ -598,7 +604,7 @@ function printAnalysisFileGroups(files, linkOptions) {
   });
   printFileGroup(files, "pinned", linkOptions, {
     title: `${colors_default.green("\u2A00 pinned")}`,
-    hint: "both changed, fork wins (pinned in cella.config.ts).",
+    hint: "both changed, fork wins (pinned in cella/cella.config.ts).",
     dateSource: "upstream"
   });
 }
@@ -653,7 +659,9 @@ function printFlagWarnings(options) {
   }
   if (unpinned) {
     console.info(
-      colors_default.yellow("\u26A0 --unpinned used: pinned files in cella.config.ts were ignored, this can result in more drifts.")
+      colors_default.yellow(
+        "\u26A0 --unpinned used: pinned files in cella/cella.config.ts were ignored, this can result in more drifts."
+      )
     );
   }
   console.info(colors_default.yellow("  Be extra careful & cherrypick what you want only."));
@@ -747,7 +755,8 @@ function readOptions(opts) {
     track: opts.track === "release" || opts.track === "branch" ? opts.track : void 0,
     force: opts.force === true,
     checkOverrides: opts.checkOverrides === true,
-    coverage: opts.coverage === true
+    coverage: opts.coverage === true,
+    directMerge: opts.directMerge === true
   };
 }
 var serviceDefinitions = [
@@ -772,7 +781,11 @@ var serviceDefinitions = [
       { flags: "--log", description: "write complete file list to cella-sync.log" },
       { flags: "--hard", description: "overwrite drifted files with upstream version (aggressive realignment)" },
       { flags: "--unpinned", description: "ignore pinned files (except package.json) to resurface upstream changes" },
-      { flags: "--track <mode>", description: "override upstream tracking for this run: release|branch" }
+      { flags: "--track <mode>", description: "override upstream tracking for this run: release|branch" },
+      {
+        flags: "--direct-merge",
+        description: "auto-merge (squash) the sync PR once checks pass \u2014 needs auto-merge enabled on the repo"
+      }
     ],
     includeInMenu: (context) => !context.isUpstreamRepo,
     menuDescription: () => "merge upstream changes + sync package.json"
@@ -859,6 +872,7 @@ function buildProgram(setSelection) {
       "  $ cella sync --hard",
       "  $ cella sync --unpinned",
       "  $ cella sync --track branch",
+      "  $ cella sync --direct-merge",
       "  $ cella audit --check-overrides",
       "  $ cella contributions --fork raak --json"
     ].join("\n")
@@ -1036,14 +1050,14 @@ import process7 from "process";
 // src/utils/git.ts
 import { execFile } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { mkdir, readdir, rmdir, unlink } from "fs/promises";
-import { dirname, join as join8 } from "path";
+import { mkdir as mkdir2, readdir, rmdir, unlink } from "fs/promises";
+import { dirname as dirname2, join as join8 } from "path";
 import { promisify } from "util";
 
 // src/utils/manifest.ts
-import { readFile, writeFile } from "fs/promises";
-import { join as join7 } from "path";
-var MANIFEST_FILE = "cella.manifest.json";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join as join7 } from "path";
+var MANIFEST_FILE = "cella/cella.manifest.json";
 async function readSyncManifest(cwd) {
   try {
     const parsed = JSON.parse(await readFile(join7(cwd, MANIFEST_FILE), "utf8"));
@@ -1059,7 +1073,9 @@ async function readManifestBase(cwd) {
   return manifest ? manifest.upstream.commit.toLowerCase() : null;
 }
 async function writeSyncManifest(cwd, manifest) {
-  await writeFile(join7(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = join7(cwd, MANIFEST_FILE);
+  await mkdir(dirname(manifestPath), { recursive: true });
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 
@@ -1371,8 +1387,8 @@ async function batchUnstageFiles(cwd, filePaths) {
   await git(["rm", "--cached", "-f", "--", ...filePaths], cwd, { ignoreErrors: true });
 }
 async function gitMv(cwd, oldPath, newPath) {
-  const newDir = dirname(join8(cwd, newPath));
-  await mkdir(newDir, { recursive: true });
+  const newDir = dirname2(join8(cwd, newPath));
+  await mkdir2(newDir, { recursive: true });
   await git(["mv", "-f", oldPath, newPath], cwd);
 }
 async function fileExistsInWorktree(cwd, filePath) {
@@ -1382,7 +1398,7 @@ async function removeFileFromWorktree(cwd, filePath) {
   const fullPath = join8(cwd, filePath);
   try {
     await unlink(fullPath);
-    await cleanupEmptyParentDirs(cwd, dirname(filePath));
+    await cleanupEmptyParentDirs(cwd, dirname2(filePath));
   } catch {
   }
 }
@@ -1397,7 +1413,7 @@ async function cleanupEmptyParentDirs(cwd, relativePath) {
     const entries = await readdir(fullPath);
     if (entries.length === 0) {
       await rmdir(fullPath);
-      await cleanupEmptyParentDirs(cwd, dirname(relativePath));
+      await cleanupEmptyParentDirs(cwd, dirname2(relativePath));
     }
   } catch {
   }
@@ -1505,7 +1521,31 @@ async function readRootTrailerBase(cwd, headRef) {
   const match = message.match(/^cella-base:\s*([0-9a-f]{40})$/im);
   return match ? match[1].toLowerCase() : null;
 }
+async function isShallowRepository(cwd) {
+  const out = await git(["rev-parse", "--is-shallow-repository"], cwd, { ignoreErrors: true });
+  return out === "true";
+}
+async function unshallowRepository(cwd) {
+  try {
+    await git(["fetch", "--unshallow"], cwd, { skipEditor: true });
+  } catch (error) {
+    const detail = error instanceof Error ? `
+
+${error.message}` : "";
+    throw new Error(
+      `this is a shallow clone and its full history could not be restored automatically.
+Sync needs the complete history to find the common ancestor with upstream. Restore it with:
+
+  git fetch --unshallow
+
+then re-run sync.${detail}`
+    );
+  }
+}
 async function ensureSyncBase(cwd, headRef, upstreamRef) {
+  if (await isShallowRepository(cwd)) {
+    await unshallowRepository(cwd);
+  }
   const nativeBase = await git(["merge-base", headRef, upstreamRef], cwd, { ignoreErrors: true });
   if (nativeBase) return;
   const sources = [
@@ -1570,6 +1610,21 @@ async function getEffectiveMergeBase(cwd, headRef, upstreamRef) {
   }
   return { base: gitBase, isStale: false, storedRef: recorded };
 }
+async function withTemporarySyncBaseGraft(cwd, headRef, baseSha, fn) {
+  const headSha = await git(["rev-parse", headRef], cwd, { ignoreErrors: true });
+  if (!headSha || !await commitObjectExists(cwd, baseSha)) return fn();
+  if (await isAncestor(cwd, baseSha, headSha)) return fn();
+  const existingReplacement = await git(["replace", "-l", headSha], cwd, { ignoreErrors: true });
+  if (existingReplacement) return fn();
+  const parentsRaw = await git(["log", "-1", "--format=%P", headSha], cwd, { ignoreErrors: true });
+  const parents = parentsRaw ? parentsRaw.split(/\s+/) : [];
+  await git(["replace", "-f", "--graft", headSha, ...parents, baseSha], cwd);
+  try {
+    return await fn();
+  } finally {
+    await git(["replace", "-d", headSha], cwd, { ignoreErrors: true });
+  }
+}
 
 // src/utils/cleanup.ts
 var WORKTREE_PREFIXES = {
@@ -1847,7 +1902,12 @@ async function applyDirectMerge(forkPath, upstreamRef, mergeBaseRef, config, onP
     }
   }
   onProgress?.("starting merge in fork...");
-  await merge(forkPath, upstreamRef, { noCommit: true, noEdit: true });
+  await withTemporarySyncBaseGraft(
+    forkPath,
+    "HEAD",
+    mergeBaseRef,
+    () => merge(forkPath, upstreamRef, { noCommit: true, noEdit: true })
+  );
   if (batchRestorePaths.length > 0) {
     onProgress?.(`batch restoring ${batchRestorePaths.length} pinned/ignored files...`);
     await batchRestoreToHead(forkPath, batchRestorePaths);
@@ -2100,7 +2160,12 @@ async function runAnalyzePreview(config, ctx, onProgress, onStep) {
   await createWorktree(forkPath, worktreePath, "HEAD");
   onStep?.("worktree created", worktreePath);
   onProgress?.("performing merge in worktree...");
-  await merge(worktreePath, ctx.upstreamRef, { noCommit: true, noEdit: true });
+  await withTemporarySyncBaseGraft(
+    worktreePath,
+    "HEAD",
+    ctx.mergeBase,
+    () => merge(worktreePath, ctx.upstreamRef, { noCommit: true, noEdit: true })
+  );
   onStep?.("merge complete", "upstream merged into worktree");
   onProgress?.("analyzing files...");
   const analyzedFiles = await analyzeRefs(
@@ -3022,7 +3087,7 @@ import {
 import { select as select2 } from "@inquirer/prompts";
 
 // src/services/contrib-core.ts
-import { dirname as dirname2, join as join12 } from "path";
+import { dirname as dirname3, join as join12, resolve as resolve3 } 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));
@@ -3038,10 +3103,10 @@ async function detectContributableFiles(repoPath, baseRef, forkRef, config, fork
   const baseFiles = await listFilesAtRef(repoPath, baseRef);
   const baseDirs = /* @__PURE__ */ new Set(["."]);
   for (const f of baseFiles) {
-    let dir = dirname2(f);
+    let dir = dirname3(f);
     while (dir !== ".") {
       baseDirs.add(dir);
-      dir = dirname2(dir);
+      dir = dirname3(dir);
     }
   }
   const files = [];
@@ -3054,7 +3119,7 @@ async function detectContributableFiles(repoPath, baseRef, forkRef, config, fork
     if (inCella && !inFork) {
       kind = "deleted";
     } else if (!inCella && inFork) {
-      if (!baseDirs.has(dirname2(file.path))) continue;
+      if (!baseDirs.has(dirname3(file.path))) continue;
       kind = "created";
     } else {
       kind = "modified";
@@ -3085,7 +3150,8 @@ async function readBlobInfo(repoPath, ref, filePath) {
 }
 async function buildContribBranch(repoPath, baseRef, forkRef, detection, forkName) {
   const branch = `contrib/${forkName}`;
-  const tmpIndex = join12(repoPath, ".git", `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
+  const gitDir = resolve3(repoPath, await git(["rev-parse", "--git-dir"], repoPath));
+  const tmpIndex = join12(gitDir, `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
   const indexEnv = { GIT_INDEX_FILE: tmpIndex };
   try {
     await git(["read-tree", baseRef], repoPath, { env: indexEnv });
@@ -3129,21 +3195,25 @@ ${commitBody}`;
 
 // src/services/fork-utils.ts
 import { existsSync as existsSync7 } from "fs";
-import { resolve as resolve3 } from "path";
+import { dirname as dirname4, resolve as resolve4 } from "path";
+async function resolveForkBasePath(repoPath) {
+  const commonDir = await git(["rev-parse", "--git-common-dir"], repoPath, { ignoreErrors: true });
+  return commonDir ? dirname4(resolve4(repoPath, commonDir)) : repoPath;
+}
 function validateForkPath(fork, basePath, requireConfig = false) {
-  const resolvedPath = resolve3(basePath, fork.localPath);
-  if (!resolvedPath.startsWith(resolve3(basePath, ".."))) {
+  const resolvedPath = resolve4(basePath, fork.localPath);
+  if (!resolvedPath.startsWith(resolve4(basePath, ".."))) {
     return { fork, resolvedPath, valid: false, error: "path resolves outside parent directory" };
   }
   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" };
+  if (requireConfig && !existsSync7(`${resolvedPath}/${CONFIG_FILE}`)) {
+    return { fork, resolvedPath, valid: false, error: `missing ${CONFIG_FILE}` };
   }
   return { fork, resolvedPath, valid: true };
 }
 function printNoForksHint(action) {
-  console.info(colors_default.yellow("no forks configured in cella.config.ts"));
+  console.info(colors_default.yellow("no forks configured in cella/cella.config.ts"));
   console.info(colors_default.dim(action));
   console.info(colors_default.dim(`  forks: [{ name: 'my-app', localPath: '../my-app', pullBranch: 'development' }]`));
 }
@@ -3312,7 +3382,8 @@ async function runContributions(config) {
     );
     console.info("");
   }
-  const validated = forks.map((fork2) => validateForkPath(fork2, config.forkPath));
+  const forkBasePath = await resolveForkBasePath(config.forkPath);
+  const validated = forks.map((fork2) => validateForkPath(fork2, forkBasePath));
   const validForks = validated.filter((v) => v.valid);
   let selectedFork;
   if (config.fork) {
@@ -3514,12 +3585,59 @@ async function runContributions(config) {
 }
 
 // src/services/forks.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import process8 from "process";
-import { Separator as Separator2, select as select3 } from "@inquirer/prompts";
+import { Separator as Separator2, select as select4 } from "@inquirer/prompts";
 
 // src/services/sync.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { select as select3 } from "@inquirer/prompts";
+
+// src/utils/gh.ts
 import { spawnSync as spawnSync2 } from "child_process";
+function ghAvailable() {
+  return spawnSync2("gh", ["--version"], { stdio: "ignore" }).status === 0;
+}
+function runGh(cwd, args) {
+  const result = spawnSync2("gh", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  return { ok: result.status === 0, output };
+}
+function filterSyncPrs(prs, prefix) {
+  return prs.filter((pr) => pr.headRefName.startsWith(`${prefix}/`));
+}
+function listOpenSyncPrs(cwd, prefix) {
+  const { ok, output } = runGh(cwd, [
+    "pr",
+    "list",
+    "--state",
+    "open",
+    "--json",
+    "number,title,headRefName,url",
+    "--limit",
+    "50"
+  ]);
+  if (!ok || !output) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    return [];
+  }
+  return filterSyncPrs(parsed, prefix).sort((a, b) => b.number - a.number);
+}
+function buildMergeArgs(ref, options = {}) {
+  const args = ["pr", "merge", ref, "--squash"];
+  if (options.auto) args.push("--auto");
+  if (options.deleteBranch) args.push("--delete-branch");
+  return args;
+}
+function mergePrSquash(cwd, ref, options = {}) {
+  return runGh(cwd, buildMergeArgs(String(ref), options));
+}
+function closePr(cwd, ref) {
+  return runGh(cwd, ["pr", "close", String(ref)]);
+}
 
 // src/services/packages.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
@@ -3859,9 +3977,6 @@ function printFinishSteps() {
 function hasStagedSyncChanges(result) {
   return result.files.some((file) => ["behind", "diverged", "renamed", "ignored", "pinned"].includes(file.status));
 }
-function ghAvailable() {
-  return spawnSync2("gh", ["--version"], { stdio: "ignore" }).status === 0;
-}
 function extractFirstUrl(output) {
   return output.match(/https?:\/\/\S+/)?.[0];
 }
@@ -3878,12 +3993,25 @@ async function flattenSyncBranch(forkPath, branch, base) {
   await flattenBranch(forkPath, base, message);
   return true;
 }
+function indentLines(text) {
+  return text.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function enableAutoMerge(forkPath, branch) {
+  console.info(colors_default.dim("enabling auto-merge (squash) once checks pass..."));
+  const merge2 = mergePrSquash(forkPath, branch, { auto: true, deleteBranch: true });
+  if (merge2.ok) return true;
+  console.info(colors_default.yellow("could not enable auto-merge (is it enabled for the repo?). merge it manually:"));
+  if (merge2.output) console.info(colors_default.dim(indentLines(merge2.output)));
+  console.info(colors_default.dim(`  gh pr merge ${branch} --squash --delete-branch`));
+  return false;
+}
 async function shipSyncBranch(config, branch) {
   const { forkPath, settings } = config;
   const base = resolveReleaseBase(settings);
   const flattened = await flattenSyncBranch(forkPath, branch, base);
   let prUrl;
   let prOpened = false;
+  let autoMergeEnabled = 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...`));
@@ -3899,7 +4027,7 @@ async function shipSyncBranch(config, branch) {
     console.info(colors_default.dim("opening a pull request..."));
     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], {
+    const pr = spawnSync3("gh", ["pr", "create", "--base", base, "--head", branch, "--title", prTitle, ...bodyArgs], {
       cwd: forkPath,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -3907,7 +4035,9 @@ async function shipSyncBranch(config, branch) {
     prUrl = extractFirstUrl(`${pr.stdout ?? ""}
 ${pr.stderr ?? ""}`);
     prOpened = pr.status === 0;
-    if (!prOpened) {
+    if (prOpened) {
+      if (config.directMerge) autoMergeEnabled = enableAutoMerge(forkPath, branch);
+    } else {
       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, prTitle);
@@ -3923,7 +4053,8 @@ ${pr.stderr ?? ""}`);
   console.info();
   if (prUrl) {
     console.info(`${colors_default.green("\u2713")} Sync pull request ${prOpened ? "opened" : "ready"}`);
-    console.info(colors_default.dim(`  ${prUrl} \xB7 branch pushed, back on '${base}'`));
+    const status = autoMergeEnabled ? `auto-merge on \u2014 squashes into '${base}' when checks pass` : `branch pushed, back on '${base}'`;
+    console.info(colors_default.dim(`  ${prUrl} \xB7 ${status}`));
   } else {
     console.info(`${colors_default.green("\u2713")} Sync branch pushed`);
     console.info(colors_default.dim(`  '${branch}' is on origin, back on '${base}'`));
@@ -3932,7 +4063,7 @@ ${pr.stderr ?? ""}`);
 function finalizeWorkspace(forkPath) {
   for (const args of [["install"], ["check"]]) {
     console.info(colors_default.dim(`running pnpm ${args.join(" ")}...`));
-    const result = spawnSync2("pnpm", args, { cwd: forkPath, stdio: "inherit" });
+    const result = spawnSync3("pnpm", args, { cwd: forkPath, stdio: "inherit" });
     if (result.status !== 0) return false;
   }
   return true;
@@ -3977,6 +4108,64 @@ async function resumeSyncMerge(config, branch) {
   console.info(colors_default.green(`committed the sync on '${branch}' as '${message}'.`));
   await shipSyncBranch(config, branch);
 }
+async function mergeOpenSyncPrs(config, open) {
+  const { forkPath, settings } = config;
+  const base = resolveReleaseBase(settings);
+  const [newest, ...superseded] = open;
+  console.info();
+  console.info(colors_default.dim(`squash-merging #${newest.number} into '${base}'...`));
+  const merged = mergePrSquash(forkPath, newest.number, { deleteBranch: true });
+  if (!merged.ok) {
+    console.info();
+    console.info(colors_default.yellow(`could not merge #${newest.number} \u2014 resolve it first, then re-run \`pnpm cella sync\`:`));
+    if (merged.output) console.info(colors_default.dim(indentLines(merged.output)));
+    console.info(colors_default.dim(`  ${newest.url}`));
+    return "cancel";
+  }
+  console.info(`${colors_default.green("\u2713")} merged #${newest.number}`);
+  await deleteBranch(forkPath, newest.headRefName);
+  for (const pr of superseded) {
+    console.info(colors_default.dim(`closing #${pr.number} \u2014 its changes are included in #${newest.number}...`));
+    closePr(forkPath, pr.number);
+    await deleteBranch(forkPath, pr.headRefName);
+  }
+  console.info(colors_default.dim(`switching to '${base}' and fast-forwarding...`));
+  await switchBranch(forkPath, base);
+  await pullFastForward(forkPath);
+  return "continue";
+}
+async function guardAgainstOpenSyncPr(config) {
+  const { forkPath } = config;
+  if (!ghAvailable() || !process.stdout.isTTY) return "continue";
+  const open = listOpenSyncPrs(forkPath, DEFAULT_SYNC_PREFIX);
+  if (open.length === 0) return "continue";
+  const many = open.length > 1;
+  console.info();
+  console.info(
+    `${warningMark} ${colors_default.yellow(`${many ? `${open.length} earlier sync PRs are` : "an earlier sync PR is"} still open and unmerged:`)}`
+  );
+  for (const pr of open) {
+    console.info(colors_default.dim(`  #${pr.number}  ${pr.title}`));
+    console.info(colors_default.dim(`         ${pr.url}`));
+  }
+  console.info(colors_default.dim(`  starting a new sync now produces a PR that re-includes ${many ? "these" : "those"} changes.`));
+  console.info();
+  const choice = await select3({
+    message: "how do you want to proceed?",
+    choices: [
+      {
+        value: "merge",
+        name: `merge ${many ? "them" : `#${open[0].number}`} first, then sync   ${colors_default.dim("(recommended)")}`
+      },
+      { value: "continue", name: `continue anyway   ${colors_default.dim("(new PR will re-include the unmerged changes)")}` },
+      { value: "cancel", name: colors_default.red("cancel") }
+    ],
+    loop: false
+  });
+  if (choice === "cancel") return "cancel";
+  if (choice === "continue") return "continue";
+  return mergeOpenSyncPrs(config, open);
+}
 async function runSyncCommand(config) {
   const { forkPath } = config;
   const currentBranch = await getCurrentBranch(forkPath);
@@ -4000,6 +4189,7 @@ commit them first (\`git commit --amend --no-edit\` or a new commit).`
     return;
   }
   await assertClean(forkPath);
+  if (await guardAgainstOpenSyncPr(config) === "cancel") return;
   const outcome = await runSyncCycle(config);
   console.info();
   if (outcome.status === "noop") {
@@ -4101,14 +4291,15 @@ async function runForks(config) {
       console.error(colors_default.red(`fork '${config.fork}' not found in config`));
       return;
     }
-    const resolvedPath = resolve4(config.forkPath, match.localPath);
+    const resolvedPath = resolve5(await resolveForkBasePath(config.forkPath), match.localPath);
     await syncFork(config, match, resolvedPath);
     return;
   }
+  const forkBasePath = await resolveForkBasePath(config.forkPath);
   while (true) {
-    const choices = await buildForkChoices(forks, config.forkPath);
+    const choices = await buildForkChoices(forks, forkBasePath);
     const forkChoices = [...choices, new Separator2("\u2500".repeat(40)), { value: "_exit", name: colors_default.dim("exit") }];
-    const selectedPath = await select3({
+    const selectedPath = await select4({
       message: "select fork to sync:",
       choices: forkChoices,
       loop: false
@@ -4116,7 +4307,7 @@ async function runForks(config) {
     if (selectedPath === "_exit") {
       process8.exit(0);
     }
-    const resolvedForkPath = resolve4(config.forkPath, selectedPath);
+    const resolvedForkPath = resolve5(forkBasePath, selectedPath);
     const selectedFork = forks.find((f) => f.localPath === selectedPath);
     if (!selectedFork) {
       console.error(colors_default.red(`fork '${selectedPath}' not found in config`));
@@ -4132,7 +4323,7 @@ import { readFile as readFile2 } from "fs/promises";
 import { join as join16 } from "path";
 
 // src/utils/coverage-utils.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import * as fs3 from "fs";
 import * as path3 from "path";
 var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -4155,7 +4346,7 @@ function formatAge(ms) {
 }
 function refreshCoverage(forkPath) {
   console.info(colors_default.dim("running `pnpm test` (this spins up Docker and runs the full suite)..."));
-  const result = spawnSync3("pnpm", ["test"], { cwd: forkPath, stdio: "inherit" });
+  const result = spawnSync4("pnpm", ["test"], { cwd: forkPath, stdio: "inherit" });
   return result.status === 0;
 }
 function printCoverageSummary(forkPath, options = {}) {
@@ -4230,6 +4421,9 @@ function classifyFile(filePath) {
   if (filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/tests/") || filePath.includes("/test/") || filePath.startsWith("tests/") || filePath.includes("/__tests__/")) {
     return "test";
   }
+  if (filePath.includes(".stories.")) {
+    return "stories";
+  }
   if (filePath.includes(".gen.") || filePath.includes(".gen/") || filePath.includes("/gen/") || filePath.startsWith("drizzle/") || filePath.includes("/drizzle/") || filePath.endsWith(".d.ts") || filePath.includes(".tsbuildinfo")) {
     return "generated";
   }
@@ -4270,6 +4464,7 @@ async function collectStats(forkPath) {
   const skipped = allFilesCount - entries.length;
   const emptyCat = () => ({
     test: { files: 0, loc: 0 },
+    stories: { files: 0, loc: 0 },
     generated: { files: 0, loc: 0 },
     json: { files: 0, loc: 0 },
     other: { files: 0, loc: 0 }
@@ -4322,6 +4517,7 @@ function printStats(stats, verbose) {
   const catEntries = [
     ["source & config", stats.categories.other],
     ["test", stats.categories.test],
+    ["stories", stats.categories.stories],
     ["generated", stats.categories.generated],
     ["json", stats.categories.json]
   ];
@@ -4334,7 +4530,7 @@ function printStats(stats, verbose) {
   console.info(DIVIDER);
   console.info();
   if (verbose) {
-    const header = `  ${"".padEnd(6)}  ${"package".padEnd(18)} ${"loc".padStart(8)} ${"test".padStart(6)} ${"gen".padStart(6)} ${"json".padStart(6)} ${"src".padStart(6)}`;
+    const header = `  ${"".padEnd(6)}  ${"package".padEnd(18)} ${"loc".padStart(8)} ${"test".padStart(6)} ${"story".padStart(6)} ${"gen".padStart(6)} ${"json".padStart(6)} ${"src".padStart(6)}`;
     console.info(colors_default.dim(header));
     for (const [name, data] of Object.entries(stats.packages)) {
       const c = data.categories;
@@ -4342,7 +4538,7 @@ function printStats(stats, verbose) {
       const srcLoc = c.other.loc;
       if (srcFiles === 0) continue;
       console.info(
-        `  ${colors_default.dim(pad(srcFiles))}  ${name.padEnd(18)} ${colors_default.cyan(formatLocColumn(srcLoc))} ${colors_default.dim(pad(c.test.files))} ${colors_default.dim(pad(c.generated.files))} ${colors_default.dim(pad(c.json.files))} ${colors_default.dim(pad(srcFiles))}`
+        `  ${colors_default.dim(pad(srcFiles))}  ${name.padEnd(18)} ${colors_default.cyan(formatLocColumn(srcLoc))} ${colors_default.dim(pad(c.test.files))} ${colors_default.dim(pad(c.stories.files))} ${colors_default.dim(pad(c.generated.files))} ${colors_default.dim(pad(c.json.files))} ${colors_default.dim(pad(srcFiles))}`
       );
     }
   } else {
@@ -4374,7 +4570,7 @@ async function runStats(forkPath, options = {}) {
 function getForkPath() {
   const envPath = getEnv("CELLA_FORK_PATH");
   if (envPath) {
-    const resolved = resolve5(envPath);
+    const resolved = resolve6(envPath);
     if (!existsSync10(resolved) || !statSync2(resolved).isDirectory()) {
       throw new Error(`CELLA_FORK_PATH is not a valid directory: ${resolved}`);
     }
@@ -4382,7 +4578,7 @@ function getForkPath() {
   }
   let cwd = process9.cwd();
   if (cwd.endsWith("/cli/cella") || cwd.endsWith("\\cli\\cella")) {
-    cwd = resolve5(cwd, "../..");
+    cwd = resolve6(cwd, "../..");
   }
   return cwd;
 }