@cellajs/cli 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,24 +1,38 @@
 #!/usr/bin/env tsx
 
 // src/cella-cli.ts
-import { existsSync as existsSync11, statSync as statSync2 } from "fs";
-import { join as join16, resolve as resolve6 } from "path";
-import process8 from "process";
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
+import { join as join16, resolve as resolve5 } from "path";
+import process9 from "process";
 
 // src/cli.ts
 import { readFileSync } from "fs";
 import { join as join4 } from "path";
-import process4 from "process";
+import process5 from "process";
 import { select } from "@inquirer/prompts";
 import { Command } from "commander";
 
 // src/utils/colors.ts
-import process2 from "process";
+import process3 from "process";
 import { styleText } from "util";
+
+// src/utils/env.ts
+import process2 from "process";
+function getEnv(name) {
+  return process2.env[name];
+}
+function hasEnv(name) {
+  return name in process2.env;
+}
+function getEnvSnapshot() {
+  return { ...process2.env };
+}
+
+// src/utils/colors.ts
 function colorsEnabled() {
-  if ("NO_COLOR" in process2.env) return false;
-  if ("FORCE_COLOR" in process2.env) return true;
-  return !!process2.stdout.isTTY;
+  if (hasEnv("NO_COLOR")) return false;
+  if (hasEnv("FORCE_COLOR")) return true;
+  return !!process3.stdout.isTTY;
 }
 function applyStyle(style, text) {
   if (!colorsEnabled()) return text;
@@ -165,18 +179,17 @@ ${z2.prettifyError(result.error)}`);
 }
 
 // src/utils/display.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync2, writeFileSync } from "fs";
+import { writeFileSync } from "fs";
 import { join as join2, resolve as resolve2 } from "path";
-import process3 from "process";
+import process4 from "process";
 
 // package.json
 var package_default = {
   name: "@cellajs/cli",
-  version: "0.0.1",
+  version: "0.0.3",
   private: false,
   license: "MIT",
-  description: "CLI for syncing and managing apps with upstream Cella.",
+  description: "CLI for managing your monorepo and syncing with upstream Cella.",
   repository: {
     type: "git",
     url: "https://github.com/cellajs/cella-cli"
@@ -225,6 +238,7 @@ var package_default = {
   dependencies: {
     "@inquirer/core": "^11.2.1",
     "@inquirer/prompts": "^8.5.2",
+    "@pierre/diffs": "^1.2.12",
     commander: "^15.0.0",
     "ts-morph": "^28.0.0",
     zod: "^4.4.3"
@@ -311,7 +325,7 @@ var checkMark = colors_default.green("\u2713");
 var TerminalSpinner = class {
   constructor(text, isSilent) {
     this.text = text;
-    this.enabled = !isSilent && !!process3.stdout.isTTY;
+    this.enabled = !isSilent && !!process4.stdout.isTTY;
   }
   text;
   frames = ["-", "\\", "|", "/"];
@@ -333,10 +347,10 @@ var TerminalSpinner = class {
       this.timer = null;
     }
     if (!this.enabled) return;
-    process3.stdout.write("\r\x1B[2K");
+    process4.stdout.write("\r\x1B[2K");
   }
   render() {
-    process3.stdout.write(`\r${colors_default.cyan(this.frames[this.frameIndex])} ${this.text}`);
+    process4.stdout.write(`\r${colors_default.cyan(this.frames[this.frameIndex])} ${this.text}`);
   }
 };
 var activeSpinner = null;
@@ -345,7 +359,7 @@ function setJsonMode(enabled) {
   jsonMode = enabled;
   if (!enabled) return;
   const toStderr = (...args) => {
-    process3.stderr.write(`${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+    process4.stderr.write(`${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
 `);
   };
   console.info = toStderr;
@@ -353,7 +367,7 @@ function setJsonMode(enabled) {
   console.warn = toStderr;
 }
 function writeStdout(text) {
-  process3.stdout.write(text.endsWith("\n") ? text : `${text}
+  process4.stdout.write(text.endsWith("\n") ? text : `${text}
 `);
 }
 function getHeader() {
@@ -376,7 +390,7 @@ function printStep(label, detail) {
   }
 }
 function createSpinner(text) {
-  const isTestEnv = !!process3.env.VITEST || process3.env.NODE_ENV === "test";
+  const isTestEnv = !!getEnv("VITEST") || getEnv("NODE_ENV") === "test";
   activeSpinner = new TerminalSpinner(text, isTestEnv || jsonMode);
   activeSpinner.start();
   return activeSpinner;
@@ -402,23 +416,6 @@ function stopSpinner() {
     activeSpinner = null;
   }
 }
-function showDiffInPager(diffOutput) {
-  if (diffOutput.length === 0) return;
-  const hasBat = spawnSync("which", ["bat"], { stdio: "pipe" }).status === 0;
-  process3.stdout.write("\x1B[?25h");
-  if (hasBat) {
-    spawnSync("bat", ["--language", "diff", "--paging", "always", "--style", "plain"], {
-      input: diffOutput,
-      stdio: ["pipe", "inherit", "inherit"]
-    });
-  } else {
-    spawnSync("less", ["-R"], {
-      input: diffOutput,
-      stdio: ["pipe", "inherit", "inherit"]
-    });
-  }
-  process3.stdout.write("\x1B[2J\x1B[0;0H");
-}
 function hyperlink(label, url) {
   if (!url) return label;
   const safeUrl = url.replace(/[\x00-\x1f\x7f]/g, "");
@@ -447,18 +444,12 @@ function formatFetchedUpstreamDetail(commitCount, commits, upstreamGitHubUrl, ma
   return lines.join("\n");
 }
 function getFileLink(filePath, commitHash, options) {
-  const { upstreamGitHubUrl, upstreamBranch, fileLinkMode = "commit", upstreamViewPath, forkPath } = options;
-  if (fileLinkMode === "local" && upstreamViewPath && forkPath) {
-    const absolutePath = resolve2(upstreamViewPath, filePath);
-    if (existsSync2(absolutePath)) {
-      const url = `vscode://file${absolutePath}`;
-      return { label: filePath.split("/").pop() || filePath, url };
-    }
-  }
+  const { upstreamGitHubUrl, upstreamBranch, fileLinkMode = "commit" } = options;
+  const mode = fileLinkMode === "local" ? "file" : fileLinkMode;
   if (!upstreamGitHubUrl) {
     return { label: commitHash?.slice(0, 9) || "" };
   }
-  if (fileLinkMode === "file" && upstreamBranch) {
+  if (mode === "file" && upstreamBranch) {
     const url = `${upstreamGitHubUrl}/blob/${upstreamBranch}/${filePath}`;
     return { label: filePath.split("/").pop() || filePath, url };
   }
@@ -625,14 +616,23 @@ function writeLogFile(forkPath, files) {
   writeFileSync(logPath, lines.join("\n"), "utf-8");
   return logPath;
 }
-function printSyncComplete(result) {
+function printSyncComplete(result, options = {}) {
   const updated = result.files.filter((file) => file.status === "behind" || file.status === "diverged").length;
   const diverged = result.files.filter((file) => file.status === "diverged").length;
   const merged = result.autoMergedFiles?.length ?? Math.max(0, diverged - result.conflicts.length);
   const conflicts = result.conflicts.length;
   console.info();
-  console.info(`${colors_default.green("\u2713")} sync complete`);
-  console.info(colors_default.dim(`  ${updated} files updated, ${merged} auto-merged, ${conflicts} conflicts`));
+  if (options.stagedBranch) {
+    console.info(`${colors_default.green("\u2713")} Sync merge staged on '${options.stagedBranch}'`);
+    console.info(
+      colors_default.dim(
+        `  ${updated} files updated, ${merged} auto-merged, ${conflicts} conflicts. Review, then rerun \`pnpm cella sync\` to finish.`
+      )
+    );
+  } else {
+    console.info(`${colors_default.green("\u2713")} sync complete`);
+    console.info(colors_default.dim(`  ${updated} files updated, ${merged} auto-merged, ${conflicts} conflicts`));
+  }
   console.info();
 }
 function printFlagWarnings(options) {
@@ -651,7 +651,7 @@ function printFlagWarnings(options) {
 }
 
 // src/utils/overrides.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { join as join3 } from "path";
 function isUnderAnyFolder(filePath, folders) {
   return folders.some((folder) => {
@@ -684,7 +684,7 @@ function validateOverrides(config, forkPath) {
         pattern: entry,
         message: `pin uses glob (not supported, use a path or folder): ${entry}`
       });
-    } else if (!existsSync3(join3(forkPath, entry))) {
+    } else if (!existsSync2(join3(forkPath, entry))) {
       warnings.push({
         type: "pinned-not-found",
         pattern: entry,
@@ -700,7 +700,7 @@ function validateOverrides(config, forkPath) {
         pattern: entry,
         message: `ignored entry uses glob (not supported, use a path or folder): ${entry}`
       });
-    } else if (!existsSync3(join3(forkPath, entry.replace(/\/+$/, "")))) {
+    } else if (!existsSync2(join3(forkPath, entry.replace(/\/+$/, "")))) {
       warnings.push({
         type: "ignored-not-found",
         pattern: entry,
@@ -751,7 +751,7 @@ var serviceDefinitions = [
       { flags: "--scope <scope>", description: "analyze scope for --list/--json: all|risk|protected" },
       { flags: "--track <mode>", description: "override upstream tracking for this run: release|branch" },
       { flags: "--diff <path>", description: "print unified diff for one file, then exit" },
-      { flags: "--open-diff <path>", description: "open VS Code side-by-side diff for one file, then exit" }
+      { flags: "--open-diff <path>", description: "open a browser diff for one file, then exit" }
     ],
     includeInMenu: (context) => !context.isUpstreamRepo
   },
@@ -878,7 +878,7 @@ async function promptForService(userConfig, forkPath) {
   if (selected === "exit") {
     console.info(colors_default.dim("exiting..."));
     console.info();
-    process4.exit(0);
+    process5.exit(0);
   }
   console.info();
   return selected;
@@ -894,7 +894,7 @@ function buildRuntimeConfig(userConfig, forkPath, selection) {
   };
 }
 async function parseCli(userConfig, forkPath) {
-  const selection = parseCommandLine(process4.argv);
+  const selection = parseCommandLine(process5.argv);
   if (selection.options.json || selection.options.diff) setJsonMode(true);
   printHeader();
   const warnings = validateOverrides(userConfig, forkPath);
@@ -909,29 +909,134 @@ async function parseCli(userConfig, forkPath) {
 }
 
 // src/services/analyze.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 
-// src/utils/cleanup.ts
-import { existsSync as existsSync5, rmSync } from "fs";
+// src/utils/diff.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { basename, join as join7 } from "path";
+import { basename, join as join5 } from "path";
 import process6 from "process";
+function gitDiffFile(cwd, range, filePath, options = {}) {
+  const args = ["diff", "--no-color"];
+  if (options.dstPrefix) args.push("--src-prefix=cella/", `--dst-prefix=${options.dstPrefix}/`);
+  args.push(range, "--", filePath);
+  try {
+    return execFileSync("git", args, { cwd, maxBuffer: 50 * 1024 * 1024 });
+  } catch (error) {
+    const stderr = error.stderr?.toString().trim();
+    throw new Error(stderr || `failed to diff ${filePath}`);
+  }
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function renderDiffPage(patch, meta) {
+  const { preloadPatchDiff } = await import("@pierre/diffs/ssr");
+  const { prerenderedHTML } = await preloadPatchDiff({
+    patch,
+    options: {
+      diffStyle: "split",
+      themeType: "system",
+      lineDiffType: "word-alt",
+      hunkSeparators: "line-info",
+      overflow: "wrap",
+      disableFileHeader: true
+    }
+  });
+  const title = `${escapeHtml(meta.filePath)} \xB7 ${escapeHtml(meta.srcLabel)} vs ${escapeHtml(meta.dstLabel)}`;
+  const note = meta.note ? `<span class="note">\xB7 ${escapeHtml(meta.note)}</span>` : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>
+  :root { color-scheme: light dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+    background: light-dark(#fafafa, #111);
+    color: light-dark(#111, #eee);
+  }
+  header {
+    display: flex; align-items: baseline; gap: 0.75rem; flex-wrap: wrap;
+    padding: 0.9rem 1.25rem;
+    border-bottom: 1px solid light-dark(#e2e2e2, #2a2a2a);
+    position: sticky; top: 0;
+    background: inherit;
+  }
+  header .brand { font-weight: 600; color: light-dark(#0891b2, #22d3ee); }
+  header code { font-family: ui-monospace, monospace; font-size: 0.9rem; }
+  header .sides { margin-left: auto; font-size: 0.8rem; opacity: 0.7; }
+  main { max-width: 1400px; margin: 1rem auto; padding: 0 1rem 2rem; }
+  .diff-shell {
+    border: 1px solid light-dark(#e2e2e2, #2a2a2a);
+    border-radius: 8px; overflow: hidden;
+    background: light-dark(#fff, #161616);
+  }
+</style>
+</head>
+<body>
+<header>
+  <span class="brand">\u29C8 cella diff</span>
+  <code>${escapeHtml(meta.filePath)}</code>
+  <span class="sides">${escapeHtml(meta.srcLabel)} \u2190 \u2192 ${escapeHtml(meta.dstLabel)} ${note}</span>
+</header>
+<main>
+  <!-- Declarative shadow DOM: the library's CSS targets :host, which only
+       matches inside a shadow root (its browser component renders into one). -->
+  <div class="diff-shell">
+    <template shadowrootmode="open">
+${prerenderedHTML}
+    </template>
+  </div>
+</main>
+</body>
+</html>`;
+}
+function openWithDefaultApp(target) {
+  try {
+    if (process6.platform === "win32") {
+      execFileSync("rundll32", ["url.dll,FileProtocolHandler", target], { stdio: "ignore" });
+    } else {
+      execFileSync(process6.platform === "darwin" ? "open" : "xdg-open", [target], { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+async function openDiffInBrowser(patch, meta, repoPath) {
+  const html = await renderDiffPage(patch, meta);
+  const dir = join5(tmpdir(), `cella-diff-${basename(repoPath)}`);
+  mkdirSync(dir, { recursive: true });
+  const outPath = join5(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 { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, join as join8 } from "path";
+import process7 from "process";
 
 // src/utils/git.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { mkdir, readdir, rmdir, unlink } from "fs/promises";
-import { dirname, join as join6 } from "path";
-import process5 from "process";
+import { dirname, join as join7 } from "path";
 import { promisify } from "util";
 
 // src/utils/manifest.ts
 import { readFile, writeFile } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var MANIFEST_FILE = "cella.manifest.json";
 async function readSyncManifest(cwd) {
   try {
-    const parsed = JSON.parse(await readFile(join5(cwd, MANIFEST_FILE), "utf8"));
+    const parsed = JSON.parse(await readFile(join6(cwd, MANIFEST_FILE), "utf8"));
     const commit = parsed?.upstream?.commit;
     if (typeof commit !== "string" || !/^[0-9a-f]{40}$/i.test(commit)) return null;
     return parsed;
@@ -944,7 +1049,7 @@ async function readManifestBase(cwd) {
   return manifest ? manifest.upstream.commit.toLowerCase() : null;
 }
 async function writeSyncManifest(cwd, manifest) {
-  await writeFile(join5(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  await writeFile(join6(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 
@@ -958,7 +1063,7 @@ function sanitizeCredentials(text) {
 }
 async function git(args, cwd, options = {}) {
   const env = {
-    ...process5.env,
+    ...getEnvSnapshot(),
     ...options.skipEditor ? { GIT_EDITOR: "true" } : {},
     ...options.env
   };
@@ -1000,13 +1105,23 @@ async function getUpstreamStatus(cwd) {
   const [ahead, behind] = counts.split(/\s+/).map((n) => Number.parseInt(n, 10) || 0);
   return { upstream, ahead: ahead ?? 0, behind: behind ?? 0 };
 }
-async function pushBranch(cwd, remote, branch) {
-  await git(["push", "-u", remote, branch], cwd);
+async function pushBranch(cwd, remote, branch, options = {}) {
+  await git(["push", "-u", ...options.forceWithLease ? ["--force-with-lease"] : [], remote, branch], cwd);
+}
+async function listBranchMergeCommits(cwd, baseRef) {
+  const out = await git(["rev-list", "--merges", "--first-parent", `${baseRef}..HEAD`], cwd, { ignoreErrors: true });
+  return out ? out.split("\n").filter(Boolean) : [];
+}
+async function flattenBranch(cwd, baseRef, message) {
+  const parent = await getMergeBase(cwd, baseRef, "HEAD");
+  const tree = await git(["rev-parse", "HEAD^{tree}"], cwd);
+  const commit = await git(["commit-tree", tree, "-p", parent, "-m", message], cwd);
+  await git(["reset", "--hard", commit], cwd);
 }
 async function commitSquash(cwd, message) {
   for (const file of ["MERGE_HEAD", "MERGE_MSG", "MERGE_MODE"]) {
-    const path4 = join6(cwd, ".git", file);
-    if (existsSync4(path4)) await unlink(path4);
+    const path4 = join7(cwd, ".git", file);
+    if (existsSync3(path4)) await unlink(path4);
   }
   await git(["commit", "-m", message], cwd, { skipEditor: true });
 }
@@ -1014,7 +1129,7 @@ async function stageAll(cwd) {
   await git(["add", "-A"], cwd);
 }
 function mergeInProgress(cwd) {
-  return existsSync4(join6(cwd, ".git", "MERGE_HEAD"));
+  return existsSync3(join7(cwd, ".git", "MERGE_HEAD"));
 }
 async function getShortSha(cwd, ref) {
   return git(["rev-parse", "--short", ref], cwd);
@@ -1244,15 +1359,15 @@ async function batchUnstageFiles(cwd, filePaths) {
   await git(["rm", "--cached", "-f", "--", ...filePaths], cwd, { ignoreErrors: true });
 }
 async function gitMv(cwd, oldPath, newPath) {
-  const newDir = dirname(join6(cwd, newPath));
+  const newDir = dirname(join7(cwd, newPath));
   await mkdir(newDir, { recursive: true });
   await git(["mv", "-f", oldPath, newPath], cwd);
 }
 async function fileExistsInWorktree(cwd, filePath) {
-  return existsSync4(join6(cwd, filePath));
+  return existsSync3(join7(cwd, filePath));
 }
 async function removeFileFromWorktree(cwd, filePath) {
-  const fullPath = join6(cwd, filePath);
+  const fullPath = join7(cwd, filePath);
   try {
     await unlink(fullPath);
     await cleanupEmptyParentDirs(cwd, dirname(filePath));
@@ -1265,7 +1380,7 @@ async function removeFileFully(cwd, filePath) {
 }
 async function cleanupEmptyParentDirs(cwd, relativePath) {
   if (!relativePath || relativePath === ".") return;
-  const fullPath = join6(cwd, relativePath);
+  const fullPath = join7(cwd, relativePath);
   try {
     const entries = await readdir(fullPath);
     if (entries.length === 0) {
@@ -1382,23 +1497,11 @@ var WORKTREE_PREFIXES = {
   view: "cella-view-"
 };
 function buildWorktreePath(kind, repoPath) {
-  return join7(tmpdir(), `${WORKTREE_PREFIXES[kind]}${basename(repoPath)}`);
+  return join8(tmpdir2(), `${WORKTREE_PREFIXES[kind]}${basename2(repoPath)}`);
 }
 function getWorktreePath(repoPath) {
   return buildWorktreePath("sync", repoPath);
 }
-function getViewWorktreePath(repoPath) {
-  return buildWorktreePath("view", repoPath);
-}
-async function refreshViewWorktree(repoPath, upstreamRef) {
-  const viewPath = getViewWorktreePath(repoPath);
-  await removeWorktree(repoPath, viewPath);
-  if (existsSync5(viewPath)) {
-    rmSync(viewPath, { recursive: true, force: true });
-  }
-  await createWorktree(repoPath, viewPath, upstreamRef);
-  return viewPath;
-}
 var cleanupRegistered = false;
 var currentWorktreePath = null;
 var currentRepoPath = null;
@@ -1412,20 +1515,22 @@ function unregisterWorktree() {
 }
 async function cleanupWorktree(repoPath, worktreePath) {
   await removeWorktree(repoPath, worktreePath);
-  if (existsSync5(worktreePath)) {
+  if (existsSync4(worktreePath)) {
     rmSync(worktreePath, { recursive: true, force: true });
   }
   unregisterWorktree();
 }
 async function cleanupLeftoverWorktrees(repoPath) {
-  const worktreePath = getWorktreePath(repoPath);
-  if (existsSync5(worktreePath)) {
-    await cleanupWorktree(repoPath, worktreePath);
+  for (const kind of Object.keys(WORKTREE_PREFIXES)) {
+    const worktreePath = buildWorktreePath(kind, repoPath);
+    if (existsSync4(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)) && !existsSync5(wt)) {
+    if (prefixes.some((prefix) => wt.includes(prefix)) && !existsSync4(wt)) {
       await removeWorktree(repoPath, wt);
     }
   }
@@ -1447,56 +1552,15 @@ async function handleAbort(signal) {
       );
     }
   }
-  process6.exit(1);
+  process7.exit(1);
 }
 function registerSignalHandlers() {
   if (cleanupRegistered) return;
-  process6.on("SIGINT", () => handleAbort("SIGINT"));
-  process6.on("SIGTERM", () => handleAbort("SIGTERM"));
+  process7.on("SIGINT", () => handleAbort("SIGINT"));
+  process7.on("SIGTERM", () => handleAbort("SIGTERM"));
   cleanupRegistered = true;
 }
 
-// src/utils/diff.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync6, mkdtempSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join8, resolve as resolve3 } from "path";
-function gitDiffFile(cwd, range, filePath, options) {
-  const args = ["diff"];
-  if (options.color === "always") args.push("--color=always");
-  if (options.color === "never") args.push("--no-color");
-  args.push("--src-prefix=cella/", `--dst-prefix=${options.dstPrefix}/`, range, "--", filePath);
-  const result = spawnSync2("git", args, { cwd, maxBuffer: 50 * 1024 * 1024 });
-  if (result.status !== 0) {
-    const stderr = result.stderr?.toString().trim();
-    throw new Error(stderr || `failed to diff ${filePath}`);
-  }
-  return result.stdout;
-}
-function openVsCodeDiff(forkPath, upstreamRef, viewPath, filePath) {
-  const forkFile = resolve3(forkPath, filePath);
-  if (viewPath) {
-    const upstreamFile = resolve3(viewPath, filePath);
-    if (existsSync6(upstreamFile)) {
-      spawnSync2("code", ["--diff", upstreamFile, forkFile], { stdio: "ignore" });
-      return;
-    }
-  }
-  const tmpDir = mkdtempSync(join8(tmpdir2(), "cella-analyze-diff-"));
-  const fileName = filePath.split("/").pop() || "file";
-  const tmpFile = join8(tmpDir, `upstream-${fileName}`);
-  const result = spawnSync2("git", ["show", `${upstreamRef}:${filePath}`], {
-    cwd: forkPath,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    const stderr = result.stderr.toString().trim();
-    throw new Error(stderr || `failed to read upstream version for ${filePath}`);
-  }
-  writeFileSync2(tmpFile, result.stdout);
-  spawnSync2("code", ["--diff", tmpFile, forkFile], { stdio: "ignore" });
-}
-
 // src/services/analyze-core.ts
 async function analyzeRefs(repoPath, localRef, incomingRef, mergeBaseRef, predicates, onProgress) {
   onProgress?.("collecting file hashes (batch)...");
@@ -2009,8 +2073,7 @@ function findTargetFile(files, targetPath) {
 }
 function printUnifiedDiff(config, filePath) {
   const diff = gitDiffFile(config.forkPath, `${config.upstreamRef}..HEAD`, filePath, {
-    dstPrefix: basename2(config.forkPath),
-    color: "never"
+    dstPrefix: basename3(config.forkPath)
   });
   writeStdout(diff.toString());
 }
@@ -2052,19 +2115,32 @@ async function runAnalyze(config) {
     }
     return result;
   }
-  const upstreamViewPath = await refreshViewWorktree(config.forkPath, config.upstreamRef);
   if (config.openDiff) {
     const file = findTargetFile(scopedFiles, config.openDiff) ?? findTargetFile(result.files, config.openDiff);
     if (!file) throw new Error(`file not found in analysis results: ${config.openDiff}`);
-    openVsCodeDiff(config.forkPath, config.upstreamRef, upstreamViewPath, file.path);
-    console.info(`${colors_default.green("\u2713")} opened VS Code diff for ${file.path}`);
+    const patch = gitDiffFile(config.forkPath, config.upstreamRef, file.path);
+    if (patch.length === 0) {
+      console.info(`${colors_default.green("\u2713")} ${file.path} is identical to upstream`);
+      return result;
+    }
+    const pagePath = await openDiffInBrowser(
+      patch.toString(),
+      {
+        filePath: file.path,
+        srcLabel: "cella",
+        dstLabel: basename3(config.forkPath),
+        note: "local working tree"
+      },
+      config.forkPath
+    );
+    console.info(`${colors_default.green("\u2713")} opened browser diff for ${file.path}`);
+    console.info(colors_default.dim(`  ${pagePath}`));
     return result;
   }
   const linkOptions = {
     upstreamGitHubUrl: result.upstreamGitHubUrl,
     upstreamBranch: result.upstreamBranch,
     fileLinkMode: config.settings.fileLinkMode,
-    upstreamViewPath,
     forkPath: config.forkPath
   };
   printAnalysisFileGroups(result.files, linkOptions);
@@ -2079,7 +2155,7 @@ async function runAnalyze(config) {
 }
 
 // src/services/audit.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync } from "child_process";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import { checkbox, confirm, Separator } from "@inquirer/prompts";
@@ -2370,7 +2446,7 @@ async function runAudit(config, options = {}) {
     if (options.force) {
       spinnerText("clearing pnpm metadata cache...");
       clearCache();
-      spawnSync3("pnpm", ["cache", "delete", "*"], {
+      spawnSync("pnpm", ["cache", "delete", "*"], {
         cwd: forkPath,
         stdio: "ignore"
       });
@@ -2660,7 +2736,7 @@ async function promptForUpdates(packages, forkPath, auditResult) {
   }
   if (runAuditFix) {
     console.info(colors_default.dim("running pnpm audit --fix override..."));
-    const auditFixResult = spawnSync3("pnpm", ["audit", "--fix", "override"], {
+    const auditFixResult = spawnSync("pnpm", ["audit", "--fix", "override"], {
       cwd: forkPath,
       stdio: "inherit"
     });
@@ -2680,7 +2756,7 @@ async function promptForUpdates(packages, forkPath, auditResult) {
     const selectedCatalogPackages = selectedPackages.filter((pkgName) => catalogPackages.has(pkgName));
     if (selectedCatalogPackages.length > 0) {
       console.info(colors_default.dim(`normalizing catalog consumers: ${selectedCatalogPackages.join(", ")}`));
-      const normalizeResult = spawnSync3("pnpm", ["-r", "up", ...selectedCatalogPackages], {
+      const normalizeResult = spawnSync("pnpm", ["-r", "up", ...selectedCatalogPackages], {
         cwd: forkPath,
         stdio: "inherit"
       });
@@ -2690,7 +2766,7 @@ async function promptForUpdates(packages, forkPath, auditResult) {
         return;
       }
     }
-    const result = spawnSync3("pnpm", ["-r", "up", "--latest", ...selectedPackages], {
+    const result = spawnSync("pnpm", ["-r", "up", "--latest", ...selectedPackages], {
       cwd: forkPath,
       stdio: "inherit"
     });
@@ -2967,16 +3043,16 @@ ${commitBody}`;
 }
 
 // src/services/fork-utils.ts
-import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve3 } from "path";
 function validateForkPath(fork, basePath, requireConfig = false) {
-  const resolvedPath = resolve4(basePath, fork.localPath);
-  if (!resolvedPath.startsWith(resolve4(basePath, ".."))) {
+  const resolvedPath = resolve3(basePath, fork.localPath);
+  if (!resolvedPath.startsWith(resolve3(basePath, ".."))) {
     return { fork, resolvedPath, valid: false, error: "path resolves outside parent directory" };
   }
-  if (!existsSync8(resolvedPath)) return { fork, resolvedPath, valid: false, error: "path does not exist" };
-  if (!existsSync8(`${resolvedPath}/.git`)) return { fork, resolvedPath, valid: false, error: "not a git repository" };
-  if (requireConfig && !existsSync8(`${resolvedPath}/cella.config.ts`)) {
+  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`)) {
     return { fork, resolvedPath, valid: false, error: "missing cella.config.ts" };
   }
   return { fork, resolvedPath, valid: true };
@@ -2988,9 +3064,10 @@ function printNoForksHint(action) {
 }
 
 // src/services/contributions.ts
-function showContribDiff(item, baseRef, cwd, forkName) {
-  const diff = gitDiffFile(cwd, `${baseRef}..${item.ref}`, item.path, { dstPrefix: forkName, color: "always" });
-  showDiffInPager(diff);
+async function showContribDiff(item, baseRef, cwd, forkName) {
+  const patch = gitDiffFile(cwd, `${baseRef}..${item.ref}`, item.path);
+  if (patch.length === 0) return null;
+  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";
@@ -3053,8 +3130,12 @@ var contribPrompt = createPrompt((config, done) => {
       return;
     }
     if (key.name === "d") {
-      showContribDiff(items[active], baseRef, cwd, forkName);
-      setStatusMsg(`viewed ${items[active].path}`);
+      try {
+        const pagePath = await showContribDiff(items[active], baseRef, cwd, forkName);
+        setStatusMsg(pagePath ? `opened ${items[active].path} in browser` : `no changes for ${items[active].path}`);
+      } catch (error) {
+        setStatusMsg(`diff failed: ${error instanceof Error ? error.message : "unknown error"}`);
+      }
       return;
     }
     if (key.name === "a") {
@@ -3095,7 +3176,7 @@ var contribPrompt = createPrompt((config, done) => {
   const header = `${colors_default.cyan("\u2B07")} ${config.message} ${colors_default.dim(`(${countInfo})`)}`;
   const keys = [
     ["\u2191\u2193", "navigate"],
-    ["d", "diff"],
+    ["d", "diff in browser"],
     ["a", "(de)select all"],
     ["space", "select"],
     ["\u23CE", "accept"],
@@ -3350,15 +3431,15 @@ async function runContributions(config) {
 }
 
 // src/services/forks.ts
-import { resolve as resolve5 } from "path";
-import process7 from "process";
+import { resolve as resolve4 } from "path";
+import process8 from "process";
 import { Separator as Separator2, select as select3 } from "@inquirer/prompts";
 
 // src/services/sync.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 
 // src/services/packages.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { join as join13 } from "path";
 function parseComparableVersion(version) {
   const trimmed = version.trim();
@@ -3463,7 +3544,7 @@ function safeMergePnpm(forkPnpm, upstreamPnpm) {
   return { merged, changed };
 }
 function readPackageJson(filePath) {
-  if (!existsSync9(filePath)) return null;
+  if (!existsSync7(filePath)) return null;
   try {
     return JSON.parse(readFileSync5(filePath, "utf-8"));
   } catch {
@@ -3485,7 +3566,7 @@ 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) => existsSync9(join13(forkPath, loc, "package.json")));
+  return upstreamPaths.filter((loc) => existsSync7(join13(forkPath, loc, "package.json")));
 }
 async function syncPackageJson(forkPath, upstreamRef, relativePath, keysToSync) {
   const changes = [];
@@ -3544,7 +3625,7 @@ async function runPackages(config, options = {}) {
   const keysToSync = config.settings.packageJsonSync || ["dependencies", "devDependencies"];
   const conflictedSet = new Set(options.conflictedFiles ?? []);
   const locations = await discoverPackageLocations(config.forkPath, config.upstreamRef);
-  const results = [];
+  let changedCount = 0;
   const skipped = [];
   for (const location of locations) {
     const pkgRelPath = location ? `${location}/package.json` : "package.json";
@@ -3553,22 +3634,15 @@ async function runPackages(config, options = {}) {
       continue;
     }
     spinnerText(`syncing ${location || "root"}/package.json...`);
-    const { updated, changes } = await syncPackageJson(config.forkPath, config.upstreamRef, location, keysToSync);
+    const { updated } = await syncPackageJson(config.forkPath, config.upstreamRef, location, keysToSync);
     if (updated) {
-      results.push({ location: location || "root", changes });
-    }
-  }
-  spinnerSuccess("package sync complete");
-  if (results.length === 0) {
-    console.info(colors_default.dim("  no package.json changes needed"));
-  } else {
-    for (const { location, changes } of results) {
-      console.info(`  ${colors_default.green("\u2713")} ${location}/package.json`);
-      for (const change of changes) {
-        console.info(`    ${colors_default.dim("\u2192")} ${change}`);
-      }
+      changedCount += 1;
     }
   }
+  spinnerSuccess(
+    "package sync complete",
+    `${changedCount} package.json${changedCount === 1 ? " was" : "s were"} changed`
+  );
   if (skipped.length > 0) {
     console.info();
     console.warn(
@@ -3633,13 +3707,13 @@ async function runSync(config, options) {
     spinnerFail("sync completed with conflicts");
   }
   printSummary(result.summary, "merge summary");
-  options?.onAfterSummary?.(result);
   if (config.logFile) {
     const logPath = writeLogFile(config.forkPath, result.files);
     console.info();
     console.info(colors_default.dim(`full file list written to: ${logPath}`));
   }
-  printSyncComplete(result);
+  const stagedBranch = options?.stagedBranch && result.conflicts.length === 0 && hasStagedSyncChanges(result) ? options.stagedBranch : void 0;
+  printSyncComplete(result, { stagedBranch });
   printFlagWarnings({ hard: config.hard, unpinned: config.unpinned });
   return result;
 }
@@ -3657,21 +3731,35 @@ function printFinishSteps() {
 function hasStagedSyncChanges(result) {
   return result.files.some((file) => ["behind", "diverged", "renamed", "ignored", "pinned"].includes(file.status));
 }
-function printCleanSyncNextStep(branch) {
-  console.info();
-  console.info(`${checkMark} ${colors_default.green(`Sync merge staged on '${branch}'. No conflicts. Review, then finish with:`)}`);
-  printFinishSteps();
-  console.info(colors_default.dim("  rerun commits the sync, pushes the branch, and opens a PR."));
-}
 function ghAvailable() {
-  return spawnSync4("gh", ["--version"], { stdio: "ignore" }).status === 0;
+  return spawnSync2("gh", ["--version"], { stdio: "ignore" }).status === 0;
+}
+function extractFirstUrl(output) {
+  return output.match(/https?:\/\/\S+/)?.[0];
+}
+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;
+  console.info(
+    colors_default.yellow(
+      `'${branch}' contains ${mergeCommits.length} merge commit(s) \u2014 the PR would list the entire upstream history.`
+    )
+  );
+  console.info(colors_default.dim(`flattening '${branch}' to a single commit (same content)...`));
+  await flattenBranch(forkPath, base, message);
+  return true;
 }
 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;
   console.info(colors_default.dim(`pushing '${branch}' to origin...`));
   try {
-    await pushBranch(forkPath, "origin", branch);
+    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:`));
@@ -3680,12 +3768,17 @@ async function shipSyncBranch(config, branch) {
   }
   if (ghAvailable()) {
     console.info(colors_default.dim("opening a pull request..."));
-    const pr = spawnSync4("gh", ["pr", "create", "--base", base, "--head", branch, "--title", SYNC_PR_TITLE, "--fill"], {
+    const pr = spawnSync2("gh", ["pr", "create", "--base", base, "--head", branch, "--title", SYNC_PR_TITLE, "--fill"], {
       cwd: forkPath,
-      stdio: "inherit"
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    if (pr.status !== 0) {
+    prUrl = extractFirstUrl(`${pr.stdout ?? ""}
+${pr.stderr ?? ""}`);
+    prOpened = pr.status === 0;
+    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);
     }
   } else {
@@ -3696,12 +3789,19 @@ async function shipSyncBranch(config, branch) {
   await switchBranch(forkPath, base);
   await pullFastForward(forkPath).catch(() => {
   });
-  console.info(colors_default.green(`done \u2014 '${branch}' is pushed and you're back on '${base}'.`));
+  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}'`));
+  } else {
+    console.info(`${colors_default.green("\u2713")} Sync branch pushed`);
+    console.info(colors_default.dim(`  '${branch}' is on origin, back on '${base}'`));
+  }
 }
 function finalizeWorkspace(forkPath) {
   for (const args of [["install"], ["check"]]) {
     console.info(colors_default.dim(`running pnpm ${args.join(" ")}...`));
-    const result = spawnSync4("pnpm", args, { cwd: forkPath, stdio: "inherit" });
+    const result = spawnSync2("pnpm", args, { cwd: forkPath, stdio: "inherit" });
     if (result.status !== 0) return false;
   }
   return true;
@@ -3709,13 +3809,7 @@ function finalizeWorkspace(forkPath) {
 async function runSyncCycle(config) {
   const { forkPath } = config;
   const branch = await setupTemporarySyncBranch(config);
-  const result = await runSync(config, {
-    onAfterSummary: (syncResult) => {
-      if (syncResult.conflicts.length === 0 && hasStagedSyncChanges(syncResult)) {
-        printCleanSyncNextStep(branch.temporaryBranch);
-      }
-    }
-  });
+  const result = await runSync(config, { stagedBranch: branch.temporaryBranch });
   if (config.settings.syncWithPackages !== false) {
     await runPackages(config, { conflictedFiles: result.conflicts });
   }
@@ -3734,7 +3828,7 @@ async function resumeSyncMerge(config, branch) {
   if (conflicts.length > 0) {
     console.info(colors_default.yellow(`${conflicts.length} file(s) still conflict on '${branch}':`));
     for (const file of conflicts) console.info(colors_default.dim(`  ${file}`));
-    console.info(colors_default.dim("resolve and stage them, then re-run `pnpm cella sync` to finish."));
+    console.info(colors_default.dim("resolve and stage them, then re-run `pnpm cella sync` to finish (it commits for you)."));
     return;
   }
   await stageAll(forkPath);
@@ -3766,14 +3860,12 @@ async function runSyncCommand(config) {
       console.info();
       console.info(
         colors_default.yellow(
-          `sync branch '${currentBranch}' has uncommitted changes that would not be shipped.
-commit them (\`git commit --amend --no-edit\` or a new commit), then re-run \`pnpm cella sync\`.`
+          `sync branch '${currentBranch}' has uncommitted changes.
+commit them first (\`git commit --amend --no-edit\` or a new commit).`
         )
       );
       return;
     }
-    console.info();
-    console.info(colors_default.green(`sync branch '${currentBranch}' is already committed.`));
     await shipSyncBranch(config, currentBranch);
     return;
   }
@@ -3786,8 +3878,10 @@ commit them (\`git commit --amend --no-edit\` or a new commit), then re-run \`pn
   }
   const { temporaryBranch } = outcome.branch;
   if (outcome.status === "conflicts") {
-    console.info(`${warningMark} ${colors_default.yellow(`conflicts on '${temporaryBranch}'. Resolve them and then:`)}`);
+    console.info(`${warningMark} ${colors_default.yellow(`conflicts on '${temporaryBranch}'. Resolve and stage them, then:`)}`);
     printFinishSteps();
+    console.info(colors_default.dim("  rerun commits the sync, pushes the branch, and opens a PR."));
+    console.info(colors_default.dim("  let the rerun commit \u2014 a manual `git commit` records a merge commit that bloats the PR."));
   }
 }
 
@@ -3877,7 +3971,7 @@ async function runForks(config) {
       console.error(colors_default.red(`fork '${config.fork}' not found in config`));
       return;
     }
-    const resolvedPath = resolve5(config.forkPath, match.localPath);
+    const resolvedPath = resolve4(config.forkPath, match.localPath);
     await syncFork(config, match, resolvedPath);
     return;
   }
@@ -3890,9 +3984,9 @@ async function runForks(config) {
       loop: false
     });
     if (selectedPath === "_exit") {
-      process7.exit(0);
+      process8.exit(0);
     }
-    const resolvedForkPath = resolve5(config.forkPath, selectedPath);
+    const resolvedForkPath = resolve4(config.forkPath, selectedPath);
     const selectedFork = forks.find((f) => f.localPath === selectedPath);
     if (!selectedFork) {
       console.error(colors_default.red(`fork '${selectedPath}' not found in config`));
@@ -3908,7 +4002,7 @@ import { readFile as readFile2 } from "fs/promises";
 import { join as join15 } from "path";
 
 // src/utils/coverage-utils.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import * as fs3 from "fs";
 import * as path3 from "path";
 var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -3931,7 +4025,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 = spawnSync5("pnpm", ["test"], { cwd: forkPath, stdio: "inherit" });
+  const result = spawnSync3("pnpm", ["test"], { cwd: forkPath, stdio: "inherit" });
   return result.status === 0;
 }
 function printCoverageSummary(forkPath, options = {}) {
@@ -4148,27 +4242,27 @@ async function runStats(forkPath, options = {}) {
 
 // src/cella-cli.ts
 function getForkPath() {
-  const envPath = process8.env.CELLA_FORK_PATH;
+  const envPath = getEnv("CELLA_FORK_PATH");
   if (envPath) {
-    const resolved = resolve6(envPath);
-    if (!existsSync11(resolved) || !statSync2(resolved).isDirectory()) {
+    const resolved = resolve5(envPath);
+    if (!existsSync9(resolved) || !statSync2(resolved).isDirectory()) {
       throw new Error(`CELLA_FORK_PATH is not a valid directory: ${resolved}`);
     }
     return resolved;
   }
-  let cwd = process8.cwd();
+  let cwd = process9.cwd();
   if (cwd.endsWith("/cli/cella") || cwd.endsWith("\\cli\\cella")) {
-    cwd = resolve6(cwd, "../..");
+    cwd = resolve5(cwd, "../..");
   }
   return cwd;
 }
 async function preflight(forkPath) {
-  if (!existsSync11(join16(forkPath, ".git"))) {
+  if (!existsSync9(join16(forkPath, ".git"))) {
     throw new Error(`not a git repository: ${forkPath}`);
   }
 }
 function isHelpOrVersionRequest() {
-  return process8.argv.slice(2).some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") || process8.argv[2] === "help";
+  return process9.argv.slice(2).some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") || process9.argv[2] === "help";
 }
 async function main() {
   registerSignalHandlers();
@@ -4209,7 +4303,7 @@ async function main() {
   } catch (error) {
     console.error();
     console.error(`${colors_default.red("\u2717")} ${error instanceof Error ? error.message : "unknown error"}`);
-    process8.exit(1);
+    process9.exit(1);
   }
 }
 main();