@cellajs/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,4216 @@
+#!/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";
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import { join as join4 } from "path";
+import process4 from "process";
+import { select } from "@inquirer/prompts";
+import { Command } from "commander";
+
+// src/utils/colors.ts
+import process2 from "process";
+import { styleText } from "util";
+function colorsEnabled() {
+  if ("NO_COLOR" in process2.env) return false;
+  if ("FORCE_COLOR" in process2.env) return true;
+  return !!process2.stdout.isTTY;
+}
+function applyStyle(style, text) {
+  if (!colorsEnabled()) return text;
+  return styleText(style, text, { validateStream: false });
+}
+var pc = {
+  blue: (text) => applyStyle("blue", text),
+  bold: (text) => applyStyle("bold", text),
+  cyan: (text) => applyStyle("cyan", text),
+  dim: (text) => applyStyle("dim", text),
+  gray: (text) => applyStyle("gray", text),
+  green: (text) => applyStyle("green", text),
+  magenta: (text) => applyStyle("magenta", text),
+  red: (text) => applyStyle("red", text),
+  white: (text) => applyStyle("white", text),
+  yellow: (text) => applyStyle("yellow", text)
+};
+var colors_default = pc;
+
+// src/utils/config.ts
+import { existsSync, realpathSync } from "fs";
+import { join, resolve } from "path";
+import { z as z2 } from "zod";
+
+// src/config/types.ts
+import { z } from "zod";
+var cellaConfigSchema = z.object({
+  settings: z.object({
+    upstreamUrl: z.string().min(1),
+    upstreamBranch: z.string().min(1).optional(),
+    upstreamTrack: z.enum(["release", "branch"]).optional(),
+    releaseBase: z.string().min(1).optional(),
+    packageJsonSync: z.array(
+      z.enum([
+        "dependencies",
+        "devDependencies",
+        "peerDependencies",
+        "optionalDependencies",
+        "scripts",
+        "engines",
+        "packageManager",
+        "overrides",
+        "pnpm"
+      ])
+    ).optional(),
+    syncWithPackages: z.boolean().optional(),
+    fileLinkMode: z.enum(["commit", "file", "local"]).optional()
+  }).strict(),
+  overrides: z.object({
+    ignored: z.array(z.string()).optional(),
+    pinned: z.array(z.string()).optional()
+  }).strict().optional(),
+  forks: z.array(
+    z.object({
+      name: z.string().min(1),
+      localPath: z.string().min(1),
+      remoteUrl: z.string().optional(),
+      pullBranch: z.string().min(1)
+    }).strict()
+  ).optional()
+}).strict();
+
+// src/utils/module-territory.ts
+import { relative, sep } from "path";
+import { Project, SyntaxKind } from "ts-morph";
+var MODULE_FILE_GLOBS = ["backend/src/modules/*/*-module.ts", "frontend/src/modules/*/*-module.ts"];
+function readOwner(call) {
+  const arg = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+  const initializer = arg?.getProperty("owner")?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+  return initializer?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+}
+function resolveAppModuleFolders(repoPath) {
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+    skipLoadingLibFiles: true
+  });
+  const sourceFiles = project.addSourceFilesAtPaths(MODULE_FILE_GLOBS.map((glob) => `${repoPath}/${glob}`));
+  const folders = /* @__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);
+  }
+  return [...folders];
+}
+
+// src/utils/config.ts
+var DEFAULT_UPSTREAM_REMOTE = "cella-upstream";
+var DEFAULT_BRANCH = "main";
+var DEFAULT_SYNC_PREFIX = "cella/sync";
+var DEFAULT_RELEASE_BASE = "main";
+function isTemporarySyncBranch(branch) {
+  return branch.startsWith(`${DEFAULT_SYNC_PREFIX}/`);
+}
+function resolveReleaseBase(settings) {
+  return settings.releaseBase ?? DEFAULT_RELEASE_BASE;
+}
+function buildTemporarySyncBranch() {
+  const now = /* @__PURE__ */ new Date();
+  const pad2 = (n) => String(n).padStart(2, "0");
+  const stamp = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}-${pad2(now.getHours())}${pad2(now.getMinutes())}`;
+  return `${DEFAULT_SYNC_PREFIX}/${stamp}`;
+}
+function resolveUpstream(settings) {
+  const track = settings.upstreamTrack ?? "release";
+  const branch = settings.upstreamBranch ?? DEFAULT_BRANCH;
+  const branchRef = `${DEFAULT_UPSTREAM_REMOTE}/${branch}`;
+  return { track, branchRef };
+}
+async function loadConfig(forkPath) {
+  const configPath = join(forkPath, "cella.config.ts");
+  if (!existsSync(configPath)) {
+    throw new Error(`config file not found: ${configPath}`);
+  }
+  const realConfigPath = realpathSync(configPath);
+  const realForkPath = realpathSync(resolve(forkPath));
+  if (!realConfigPath.startsWith(`${realForkPath}/`)) {
+    throw new Error("config path resolves outside fork directory");
+  }
+  let configModule;
+  try {
+    configModule = await import(realConfigPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`failed to load ${configPath}: ${message}`);
+  }
+  const result = cellaConfigSchema.safeParse(configModule.default);
+  if (!result.success) {
+    throw new Error(`invalid ${configPath}:
+${z2.prettifyError(result.error)}`);
+  }
+  const config = result.data;
+  const appModuleFolders = resolveAppModuleFolders(realForkPath);
+  if (appModuleFolders.length > 0) {
+    const existing = config.overrides?.ignored ?? [];
+    config.overrides = {
+      ...config.overrides,
+      ignored: [.../* @__PURE__ */ new Set([...existing, ...appModuleFolders])]
+    };
+  }
+  return config;
+}
+
+// src/utils/display.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2, writeFileSync } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import process3 from "process";
+
+// package.json
+var package_default = {
+  name: "@cellajs/cli",
+  version: "0.0.1",
+  private: false,
+  license: "MIT",
+  description: "CLI for syncing and managing apps with upstream Cella.",
+  repository: {
+    type: "git",
+    url: "https://github.com/cellajs/cella-cli"
+  },
+  homepage: "https://cellajs.com",
+  author: "CellaJS <info@cellajs.com>",
+  engines: {
+    node: "24.x"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  exports: {
+    ".": "./dist/index.js",
+    "./config": {
+      types: "./dist/config.d.ts",
+      import: "./dist/config.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist",
+    "index.js",
+    "README.md"
+  ],
+  bin: {
+    cella: "index.js"
+  },
+  imports: {
+    "#/*": "./src/*"
+  },
+  scripts: {
+    start: "tsx index.ts",
+    clean: "rimraf ./dist",
+    build: "tsup",
+    "test-build": "pnpm run build && node index.js --help",
+    prepublishOnly: "pnpm run test:release",
+    check: "pnpm ts && pnpm biome check --write .",
+    ts: "tsgo --pretty",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    test: "vitest run",
+    "test:release": "pnpm run build && vitest run --config vitest.release.config.ts",
+    "test:watch": "vitest",
+    prepare: "lefthook install"
+  },
+  dependencies: {
+    "@inquirer/core": "^11.2.1",
+    "@inquirer/prompts": "^8.5.2",
+    commander: "^15.0.0",
+    "ts-morph": "^28.0.0",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.5.2",
+    "@commitlint/cli": "^21.2.0",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@evilmartians/lefthook": "^2.1.9",
+    "@types/node": "24.10.13",
+    "@typescript/native-preview": "7.0.0-dev.20260702.3",
+    rimraf: "^6.1.3",
+    tsup: "^8.5.1",
+    tsx: "^4.22.4",
+    typescript: "^6.0.3",
+    vitest: "^4.1.9"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "cella",
+    "cellajs",
+    "cli",
+    "sync",
+    "template"
+  ],
+  packageManager: "pnpm@11.8.0",
+  commitlint: {
+    extends: [
+      "@commitlint/config-conventional"
+    ],
+    rules: {
+      "type-enum": [
+        2,
+        "always",
+        [
+          "feat",
+          "fix",
+          "perf",
+          "refactor",
+          "revert",
+          "docs",
+          "chore",
+          "build",
+          "ci",
+          "style",
+          "test"
+        ]
+      ],
+      "header-max-length": [
+        2,
+        "always",
+        120
+      ],
+      "body-max-line-length": [
+        0,
+        "always",
+        200
+      ],
+      "footer-max-line-length": [
+        0,
+        "always",
+        200
+      ]
+    }
+  }
+};
+
+// 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;
+var DIVIDER = "\u2500".repeat(60);
+var warningMark = colors_default.yellow("\u26A0");
+var checkMark = colors_default.green("\u2713");
+var TerminalSpinner = class {
+  constructor(text, isSilent) {
+    this.text = text;
+    this.enabled = !isSilent && !!process3.stdout.isTTY;
+  }
+  text;
+  frames = ["-", "\\", "|", "/"];
+  frameIndex = 0;
+  timer = null;
+  enabled;
+  start() {
+    if (!this.enabled || this.timer) return this;
+    this.render();
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      this.render();
+    }, 80);
+    return this;
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (!this.enabled) return;
+    process3.stdout.write("\r\x1B[2K");
+  }
+  render() {
+    process3.stdout.write(`\r${colors_default.cyan(this.frames[this.frameIndex])} ${this.text}`);
+  }
+};
+var activeSpinner = null;
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+  if (!enabled) return;
+  const toStderr = (...args) => {
+    process3.stderr.write(`${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+  };
+  console.info = toStderr;
+  console.log = toStderr;
+  console.warn = toStderr;
+}
+function writeStdout(text) {
+  process3.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+}
+function getHeader() {
+  const right = "cellajs.com";
+  const visibleLeft = `\u29C8 ${NAME} v${VERSION}`;
+  const padding = Math.max(1, 60 - visibleLeft.length - right.length);
+  return `${colors_default.cyan(`\u29C8 ${NAME}`)}${colors_default.dim(` \xB7 v${VERSION}`)}${colors_default.cyan(`${" ".repeat(padding)}${right}`)}`;
+}
+function printHeader() {
+  console.info();
+  console.info(getHeader());
+  console.info(DIVIDER);
+  console.info();
+}
+function printStep(label, detail) {
+  console.info(`${checkMark} ${label}`);
+  if (detail) {
+    console.info(`  ${colors_default.dim(detail)}`);
+    console.info();
+  }
+}
+function createSpinner(text) {
+  const isTestEnv = !!process3.env.VITEST || process3.env.NODE_ENV === "test";
+  activeSpinner = new TerminalSpinner(text, isTestEnv || jsonMode);
+  activeSpinner.start();
+  return activeSpinner;
+}
+function spinnerSuccess(message, detail) {
+  stopSpinner();
+  if (message) {
+    printStep(message, detail);
+  }
+}
+function spinnerFail(message) {
+  stopSpinner();
+  console.info(`${colors_default.red("\u2717")} ${message}`);
+}
+function spinnerText(text) {
+  if (activeSpinner) {
+    activeSpinner.text = text;
+  }
+}
+function stopSpinner() {
+  if (activeSpinner) {
+    activeSpinner.stop();
+    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, "");
+  return `\x1B]8;;${safeUrl}\x07${label}\x1B]8;;\x07`;
+}
+function getVsCodeOpenFileLink(filePath, options) {
+  const { forkPath } = options;
+  if (!forkPath) return filePath;
+  const absolutePath = resolve2(forkPath, filePath);
+  const url = `vscode://file${absolutePath}`;
+  return hyperlink(filePath, url);
+}
+function formatFetchedUpstreamDetail(commitCount, commits, upstreamGitHubUrl, maxShownCommits = 50) {
+  const commitLabel = commitCount === 1 ? "1 new commit" : `${commitCount} new commits`;
+  const lines = [`${commitLabel} since last merge`];
+  const shown = commits.slice(0, maxShownCommits);
+  for (const commit of shown) {
+    const shortHash = commit.hash.slice(0, 7);
+    const commitUrl = upstreamGitHubUrl ? `${upstreamGitHubUrl}/commit/${commit.hash}` : void 0;
+    const hashLabel = hyperlink(shortHash, commitUrl);
+    lines.push(`  ${hashLabel} "${commit.message}" (${commit.date})`);
+  }
+  if (commitCount > shown.length) {
+    lines.push(`  ... and ${commitCount - shown.length} more`);
+  }
+  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 };
+    }
+  }
+  if (!upstreamGitHubUrl) {
+    return { label: commitHash?.slice(0, 9) || "" };
+  }
+  if (fileLinkMode === "file" && upstreamBranch) {
+    const url = `${upstreamGitHubUrl}/blob/${upstreamBranch}/${filePath}`;
+    return { label: filePath.split("/").pop() || filePath, url };
+  }
+  if (commitHash) {
+    const url = `${upstreamGitHubUrl}/commit/${commitHash}`;
+    return { label: commitHash.slice(0, 9), url };
+  }
+  return { label: "" };
+}
+function printSectionHeader(title) {
+  console.info();
+  console.info(title);
+  console.info(DIVIDER);
+  console.info();
+}
+function formatFileDateInfo(filePath, commit, date, linkOptions) {
+  const link = getFileLink(filePath, commit, linkOptions);
+  const linkLabel = link.label ? hyperlink(link.label, link.url) : "";
+  return date ? colors_default.dim(` \u2260 ${date} ${linkLabel}`) : "";
+}
+function formatMergeInProgressDetail(conflictCount, autoMergedFiles, linkOptions, maxFiles = 100) {
+  const lines = [`${conflictCount} conflicts to resolve in IDE`];
+  if (autoMergedFiles.length === 0) {
+    return lines.join("\n");
+  }
+  lines.push("");
+  lines.push(`  auto-merged files (${autoMergedFiles.length}):`);
+  const shown = autoMergedFiles.slice(0, maxFiles);
+  for (const filePath of shown) {
+    const fileLink = getVsCodeOpenFileLink(filePath, linkOptions);
+    lines.push(`  - ${fileLink}`);
+  }
+  if (autoMergedFiles.length > shown.length) {
+    lines.push(`  ... + ${autoMergedFiles.length - shown.length} more`);
+  }
+  return lines.join("\n");
+}
+var statusConfig = {
+  behind: { icon: colors_default.cyan("\u2193"), label: "behind", color: colors_default.cyan, description: "upstream changed, will sync" },
+  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" },
+  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" },
+  deleted: { icon: colors_default.red("\u2717"), label: "deleted", color: colors_default.red },
+  renamed: { icon: colors_default.blue("\u2192"), label: "renamed", color: colors_default.blue }
+};
+var summaryStatusConfig = {
+  ...statusConfig,
+  managed: {
+    icon: colors_default.cyan("\u25C7"),
+    label: "managed",
+    color: colors_default.cyan,
+    description: "package/config files handled separately"
+  },
+  ignored: { ...statusConfig.ignored, description: "protected by ignored config" }
+};
+var statusOrder = Object.keys(statusConfig);
+function printSummary(summary, title = "summary") {
+  printSectionHeader(colors_default.cyan(title));
+  const maxCount = Math.max(
+    summary.managed,
+    summary.ignored,
+    summary.identical,
+    summary.ahead,
+    summary.local,
+    summary.drifted,
+    summary.behind,
+    summary.diverged,
+    summary.pinned,
+    summary.deleted,
+    summary.renamed
+  );
+  const countWidth = String(maxCount).length + 1;
+  const printLine = (status, count) => {
+    const { icon, label, color, description } = summaryStatusConfig[status];
+    const countStr = color(String(count).padStart(countWidth));
+    const desc = description ? colors_default.dim(description) : "";
+    console.info(`  ${icon} ${countStr}  ${label.padEnd(15)}${desc}`);
+  };
+  printLine("managed", summary.managed);
+  printLine("ignored", summary.ignored);
+  console.info();
+  printLine("identical", summary.identical);
+  console.info();
+  printLine("ahead", summary.ahead);
+  printLine("local", summary.local);
+  printLine("drifted", summary.drifted);
+  console.info();
+  printLine("diverged", summary.diverged);
+  printLine("pinned", summary.pinned);
+  console.info();
+  printLine("behind", summary.behind);
+}
+function printFileGroup(files, status, linkOptions, options) {
+  const filtered = files.filter((f) => f.status === status && !isManagedFile(f.path));
+  if (filtered.length === 0) return;
+  const config = statusConfig[status];
+  const title = options?.title ?? `${config.icon} ${config.label}`;
+  printSectionHeader(`${title} ${colors_default.dim(`\xB7 ${filtered.length} files`)}`);
+  const useUpstream = options?.dateSource === "upstream";
+  const maxLines = 100;
+  const shown = filtered.length > maxLines ? filtered.slice(0, maxLines) : filtered;
+  for (const file of shown) {
+    const commit = useUpstream ? file.upstreamCommit : file.changedCommit;
+    const date = useUpstream ? file.upstreamChangedAt : file.changedAt;
+    const dateInfo = formatFileDateInfo(file.path, commit, date, linkOptions);
+    console.info(`  ${config.icon} ${file.path}${dateInfo}`);
+  }
+  if (filtered.length > maxLines) {
+    console.info(colors_default.dim(`  ... + ${filtered.length - maxLines} more`));
+  }
+  if (options?.hint) {
+    console.info();
+    console.info(colors_default.dim(`  ${options.hint}`));
+  }
+}
+function printAnalysisFileGroups(files, linkOptions) {
+  printFileGroup(files, "behind", linkOptions, {
+    title: colors_default.cyan("\u2193 behind on upstream")
+  });
+  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."
+  });
+  printFileGroup(files, "drifted", linkOptions, {
+    title: `${warningMark} ${colors_default.yellow("drifted from upstream")}`,
+    hint: "these files have fork changes but are not pinned or ignored."
+  });
+  printFileGroup(files, "diverged", linkOptions, {
+    title: `${colors_default.magenta("\u21C5 diverged")}`,
+    hint: "both fork and upstream changed.",
+    dateSource: "upstream"
+  });
+  printFileGroup(files, "pinned", linkOptions, {
+    title: `${colors_default.green("\u2A00 pinned")}`,
+    hint: "both changed, fork wins (pinned in cella.config.ts).",
+    dateSource: "upstream"
+  });
+}
+function writeLogFile(forkPath, files) {
+  const logPath = join2(forkPath, "cella-sync.log");
+  const lines = [
+    `cella sync analysis - ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    DIVIDER,
+    "",
+    `complete file list (${files.length} files)`,
+    DIVIDER,
+    ""
+  ];
+  const sortedFiles = [...files].sort((a, b) => {
+    const aOrder = statusOrder.indexOf(a.status);
+    const bOrder = statusOrder.indexOf(b.status);
+    if (aOrder !== bOrder) return aOrder - bOrder;
+    return a.path.localeCompare(b.path);
+  });
+  for (const file of sortedFiles) {
+    const config = statusConfig[file.status];
+    const icon = config.icon.replace(/\x1b\[[0-9;]*m/g, "");
+    lines.push(`  ${icon} ${config.label.padEnd(12)} ${file.path}`);
+  }
+  writeFileSync(logPath, lines.join("\n"), "utf-8");
+  return logPath;
+}
+function printSyncComplete(result) {
+  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`));
+  console.info();
+}
+function printFlagWarnings(options) {
+  const { hard, unpinned } = options;
+  if (!hard && !unpinned) return;
+  if (hard) {
+    console.info(colors_default.yellow("\u26A0 --hard used: drifted files were treated as behind, overwriting with incoming."));
+  }
+  if (unpinned) {
+    console.info(
+      colors_default.yellow("\u26A0 --unpinned used: pinned files in cella.config.ts were ignored, this can result in more drifts.")
+    );
+  }
+  console.info(colors_default.yellow("  Be extra careful & cherrypick what you want only."));
+  console.info();
+}
+
+// src/utils/overrides.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function isUnderAnyFolder(filePath, folders) {
+  return folders.some((folder) => {
+    const entry = folder.replace(/\/+$/, "");
+    return filePath === entry || filePath.startsWith(`${entry}/`);
+  });
+}
+function isIgnored(filePath, config) {
+  return isUnderAnyFolder(filePath, config.overrides?.ignored || []);
+}
+function isPinned(filePath, config) {
+  if (isManagedFile(filePath)) return true;
+  return isUnderAnyFolder(filePath, config.overrides?.pinned || []);
+}
+function isPinnedForSync(filePath, config, unpinned) {
+  if (isManagedFile(filePath)) return true;
+  if (unpinned) return false;
+  return isPinned(filePath, config);
+}
+function hasGlobChars(entry) {
+  return entry.includes("*") || entry.includes("?");
+}
+function validateOverrides(config, forkPath) {
+  const warnings = [];
+  const pinned = config.overrides?.pinned || [];
+  for (const entry of pinned) {
+    if (hasGlobChars(entry)) {
+      warnings.push({
+        type: "pinned-glob",
+        pattern: entry,
+        message: `pin uses glob (not supported, use a path or folder): ${entry}`
+      });
+    } else if (!existsSync3(join3(forkPath, entry))) {
+      warnings.push({
+        type: "pinned-not-found",
+        pattern: entry,
+        message: `pin not found: ${entry}`
+      });
+    }
+  }
+  const ignored = config.overrides?.ignored || [];
+  for (const entry of ignored) {
+    if (hasGlobChars(entry)) {
+      warnings.push({
+        type: "ignored-not-found",
+        pattern: entry,
+        message: `ignored entry uses glob (not supported, use a path or folder): ${entry}`
+      });
+    } else if (!existsSync3(join3(forkPath, entry.replace(/\/+$/, "")))) {
+      warnings.push({
+        type: "ignored-not-found",
+        pattern: entry,
+        message: `ignored entry not found: ${entry}`
+      });
+    }
+  }
+  return warnings;
+}
+function printWarnings(warnings) {
+  for (const warning of warnings) {
+    console.info(`${warningMark} ${warning.message}`);
+  }
+}
+
+// src/cli.ts
+function readOptions(opts) {
+  const scope = typeof opts.scope === "string" ? opts.scope : void 0;
+  if (scope && scope !== "all" && scope !== "risk" && scope !== "protected") {
+    throw new Error(`invalid --scope '${scope}'. expected one of: all, risk, protected`);
+  }
+  const normalizedScope = scope;
+  return {
+    logFile: opts.log === true,
+    verbose: opts.verbose === true,
+    list: opts.list === true,
+    json: opts.json === true,
+    diff: typeof opts.diff === "string" ? opts.diff : void 0,
+    openDiff: typeof opts.openDiff === "string" ? opts.openDiff : void 0,
+    scope: normalizedScope,
+    fork: typeof opts.fork === "string" ? opts.fork : void 0,
+    hard: opts.hard === true,
+    unpinned: opts.unpinned === true,
+    track: opts.track === "release" || opts.track === "branch" ? opts.track : void 0,
+    force: opts.force === true,
+    checkOverrides: opts.checkOverrides === true,
+    coverage: opts.coverage === true
+  };
+}
+var serviceDefinitions = [
+  {
+    name: "analyze",
+    description: "dry run to see what would change on sync",
+    options: [
+      { flags: "--log", description: "write complete file list to cella-sync.log" },
+      { flags: "--list", description: "non-interactive output for tooling (one file per line)" },
+      { flags: "--json", description: "machine-readable output for tooling/agents" },
+      { 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" }
+    ],
+    includeInMenu: (context) => !context.isUpstreamRepo
+  },
+  {
+    name: "sync",
+    description: "merge upstream changes into your app",
+    options: [
+      { 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" }
+    ],
+    includeInMenu: (context) => !context.isUpstreamRepo,
+    menuDescription: () => "merge upstream changes + sync package.json"
+  },
+  {
+    name: "audit",
+    description: "check for outdated packages & vulnerabilities",
+    options: [
+      { flags: "--list", description: "skip interactive update prompts after printing audit results" },
+      { flags: "--force", description: "bypass pnpm metadata cache for fresh registry data" },
+      { flags: "--check-overrides", description: "check which pnpm.overrides are still needed" }
+    ]
+  },
+  {
+    name: "forks",
+    description: "sync downstream to local fork repositories",
+    options: [
+      { flags: "--fork <name>", description: "pre-select fork by name (skips fork selection prompt)" },
+      { flags: "--log", description: "write complete file list to cella-sync.log for each synced fork" },
+      { flags: "-V, --verbose", description: "show detailed output during operations" },
+      { flags: "--hard", description: "overwrite drifted files with upstream version (aggressive realignment)" }
+    ],
+    includeInMenu: (context) => context.hasForks
+  },
+  {
+    name: "contributions",
+    description: "pull and adopt changes from forks",
+    options: [
+      { flags: "--fork <name>", description: "select a specific fork directly (skips fork selection)" },
+      { flags: "--list", description: "non-interactive output (one file per line)" },
+      { flags: "--json", description: "machine-readable JSON output for tooling/agents" },
+      { flags: "--diff <path>", description: "print the unified diff for a single contributed file, then exit" }
+    ],
+    includeInMenu: (context) => context.hasForks
+  },
+  {
+    name: "stats",
+    description: "count files by category and workspace package",
+    options: [
+      { flags: "-V, --verbose", description: "show detailed output during operations" },
+      { flags: "--coverage", description: "regenerate test coverage before showing the stats summary" }
+    ]
+  }
+];
+async function getMenuContext(userConfig, forkPath) {
+  return {
+    hasForks: (userConfig.forks?.length ?? 0) > 0,
+    isUpstreamRepo: JSON.parse(readFileSync(join4(forkPath, "package.json"), "utf8")).name === "cella"
+  };
+}
+function buildServiceChoices(context) {
+  const label = (name) => name.padEnd(14);
+  const baseChoices = serviceDefinitions.filter((service) => service.includeInMenu?.(context) ?? true).map((service) => ({
+    value: service.name,
+    name: `${label(service.name)}${colors_default.dim(service.menuDescription?.(context) ?? service.description)}`
+  }));
+  return [
+    ...baseChoices,
+    { type: "separator", separator: "\u2500".repeat(40) },
+    { value: "exit", name: colors_default.red(`${label("exit")}${colors_default.dim("quit without doing anything")}`) }
+  ];
+}
+function addServiceCommand(program, definition, setSelection) {
+  const command = program.command(definition.name).description(definition.description);
+  for (const option of definition.options ?? []) {
+    command.option(option.flags, option.description);
+  }
+  command.action((opts) => {
+    setSelection({
+      service: definition.name,
+      options: readOptions(opts)
+    });
+  });
+}
+function buildProgram(setSelection) {
+  const program = new Command(NAME).name("cella").version(VERSION, "-v, --version", "output the current version").usage("[service] [options]").helpOption("-h, --help", "display help for a command").showHelpAfterError().addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  $ cella analyze",
+      "  $ cella analyze --json --scope risk",
+      "  $ cella analyze --open-diff frontend/src/routes/index.tsx",
+      "  $ cella sync --hard",
+      "  $ cella sync --unpinned",
+      "  $ cella sync --track branch",
+      "  $ cella audit --check-overrides",
+      "  $ cella contributions --fork raak --json"
+    ].join("\n")
+  );
+  for (const definition of serviceDefinitions) {
+    addServiceCommand(program, definition, setSelection);
+  }
+  return program;
+}
+function parseCommandLine(argv) {
+  if (argv.length <= 2) {
+    return { options: readOptions({}) };
+  }
+  let selection = { options: readOptions({}) };
+  const program = buildProgram((nextSelection) => {
+    selection = nextSelection;
+  });
+  program.parse(argv);
+  return selection;
+}
+async function promptForService(userConfig, forkPath) {
+  const selected = await select({
+    message: "choose a service:",
+    choices: buildServiceChoices(await getMenuContext(userConfig, forkPath)),
+    loop: false
+  });
+  if (selected === "exit") {
+    console.info(colors_default.dim("exiting..."));
+    console.info();
+    process4.exit(0);
+  }
+  console.info();
+  return selected;
+}
+function buildRuntimeConfig(userConfig, forkPath, selection) {
+  const { branchRef } = resolveUpstream(userConfig.settings);
+  return {
+    ...userConfig,
+    forkPath,
+    upstreamRef: branchRef,
+    service: selection.service ?? "analyze",
+    ...selection.options
+  };
+}
+async function parseCli(userConfig, forkPath) {
+  const selection = parseCommandLine(process4.argv);
+  if (selection.options.json || selection.options.diff) setJsonMode(true);
+  printHeader();
+  const warnings = validateOverrides(userConfig, forkPath);
+  if (warnings.length > 0) {
+    printWarnings(warnings);
+    console.info();
+  }
+  if (!selection.service) {
+    selection.service = await promptForService(userConfig, forkPath);
+  }
+  return buildRuntimeConfig(userConfig, forkPath, selection);
+}
+
+// src/services/analyze.ts
+import { basename as basename2 } from "path";
+
+// src/utils/cleanup.ts
+import { existsSync as existsSync5, rmSync } from "fs";
+import { tmpdir } from "os";
+import { basename, join as join7 } from "path";
+import process6 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 join6 } from "path";
+import process5 from "process";
+import { promisify } from "util";
+
+// src/utils/manifest.ts
+import { readFile, writeFile } from "fs/promises";
+import { join as join5 } 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 commit = parsed?.upstream?.commit;
+    if (typeof commit !== "string" || !/^[0-9a-f]{40}$/i.test(commit)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function readManifestBase(cwd) {
+  const manifest = await readSyncManifest(cwd);
+  return manifest ? manifest.upstream.commit.toLowerCase() : null;
+}
+async function writeSyncManifest(cwd, manifest) {
+  await writeFile(join5(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+
+// src/utils/git.ts
+var execFileAsync = promisify(execFile);
+function sanitizeCredentials(text) {
+  return text.replace(/https?:\/\/[^@\s]+@/g, (match) => {
+    const protocol = match.startsWith("https") ? "https" : "http";
+    return `${protocol}://***@`;
+  });
+}
+async function git(args, cwd, options = {}) {
+  const env = {
+    ...process5.env,
+    ...options.skipEditor ? { GIT_EDITOR: "true" } : {},
+    ...options.env
+  };
+  const maxBuffer = options.maxBuffer ?? 50 * 1024 * 1024;
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd, env, maxBuffer });
+    return stdout.trim();
+  } catch (error) {
+    if (options.ignoreErrors) return "";
+    if (error instanceof Error) {
+      error.message = sanitizeCredentials(error.message);
+    }
+    throw error;
+  }
+}
+async function getCurrentBranch(cwd) {
+  return git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+}
+async function switchBranch(cwd, branch) {
+  await git(["switch", branch], cwd);
+}
+async function createBranchFrom(cwd, branch, startPoint) {
+  await git(["switch", "-c", branch, startPoint], cwd);
+}
+async function deleteBranch(cwd, branch) {
+  await git(["branch", "-D", branch], cwd, { ignoreErrors: true });
+}
+async function pullFastForward(cwd) {
+  await git(["pull", "--ff-only"], cwd, { ignoreErrors: true, skipEditor: true });
+}
+async function getUpstreamStatus(cwd) {
+  const upstream = await git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], cwd, {
+    ignoreErrors: true
+  });
+  if (!upstream) return { upstream: null, ahead: 0, behind: 0 };
+  const remote = upstream.split("/")[0];
+  await git(["fetch", remote], cwd, { ignoreErrors: true, skipEditor: true });
+  const counts = await git(["rev-list", "--left-right", "--count", `HEAD...${upstream}`], cwd, { ignoreErrors: true });
+  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 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);
+  }
+  await git(["commit", "-m", message], cwd, { skipEditor: true });
+}
+async function stageAll(cwd) {
+  await git(["add", "-A"], cwd);
+}
+function mergeInProgress(cwd) {
+  return existsSync4(join6(cwd, ".git", "MERGE_HEAD"));
+}
+async function getShortSha(cwd, ref) {
+  return git(["rev-parse", "--short", ref], cwd);
+}
+async function getWorkingTreeChangeCount(cwd) {
+  const status = await git(["status", "--porcelain"], cwd);
+  if (!status) return 0;
+  return status.split("\n").filter(Boolean).length;
+}
+async function remoteExists(cwd, remoteName) {
+  const remotes = await git(["remote"], cwd);
+  return remotes.split("\n").includes(remoteName);
+}
+async function ensureRemote(cwd, remoteName, url) {
+  if (await remoteExists(cwd, remoteName)) {
+    await git(["remote", "set-url", remoteName, url], cwd);
+  } else {
+    await git(["remote", "add", remoteName, url], cwd);
+  }
+}
+async function fetch2(cwd, remoteName) {
+  await git(["fetch", remoteName], cwd);
+}
+async function fetchUpstreamTags(cwd, remoteName) {
+  await git(["fetch", remoteName, "--no-tags", `+refs/tags/*:refs/${remoteName}/tags/*`], cwd);
+}
+async function resolveLatestReleaseTag(cwd, remoteName) {
+  const prefix = `refs/${remoteName}/tags/`;
+  const output = await git(["for-each-ref", "--sort=-version:refname", "--format=%(refname)", prefix], cwd, {
+    ignoreErrors: true
+  });
+  if (!output) return null;
+  for (const line of output.split("\n")) {
+    const ref = line.trim();
+    if (!ref) continue;
+    const tag = ref.slice(prefix.length);
+    if (/^v\d/.test(tag)) return { tag, ref };
+  }
+  return null;
+}
+async function getCommitInfo(cwd, ref) {
+  const format = "%H%n%s%n%ar";
+  const output = await git(["log", "-1", `--format=${format}`, ref], cwd);
+  const [hash, message, date] = output.split("\n");
+  return { hash, message, date };
+}
+async function countCommitsBetween(cwd, fromRef, toRef) {
+  const output = await git(["rev-list", "--count", `${fromRef}..${toRef}`], cwd);
+  return Number.parseInt(output.trim(), 10) || 0;
+}
+async function listCommitsBetween(cwd, fromRef, toRef, options = {}) {
+  const { oldestFirst = true, skip = 0, limit } = options;
+  const args = ["log", "--format=%H%x1f%s%x1f%ar"];
+  if (oldestFirst) args.push("--reverse");
+  args.push(`${fromRef}..${toRef}`);
+  const output = await git(args, cwd, { ignoreErrors: true });
+  if (!output) return [];
+  const commits = [];
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const [hash, message, date] = line.split("");
+    if (!hash || !message || !date) continue;
+    commits.push({ hash, message, date });
+  }
+  const normalizedSkip = Math.max(0, skip);
+  const normalizedLimit = typeof limit === "number" && limit > 0 ? limit : void 0;
+  if (normalizedSkip === 0 && normalizedLimit === void 0) {
+    return commits;
+  }
+  const start = Math.min(normalizedSkip, commits.length);
+  const end = normalizedLimit === void 0 ? commits.length : Math.min(start + normalizedLimit, commits.length);
+  return commits.slice(start, end);
+}
+async function getFileChangeInfo(cwd, fromRef, toRef) {
+  const info = /* @__PURE__ */ new Map();
+  try {
+    const output = await git(["log", "--name-only", "--format=%h %ar", `${fromRef}..${toRef}`], cwd, {
+      ignoreErrors: true
+    });
+    if (!output.trim()) return info;
+    const lines = output.split("\n");
+    let currentHash = "";
+    let currentDate = "";
+    for (const line of lines) {
+      if (!line) continue;
+      const match = line.match(/^([a-f0-9]{7,})\s+(.+)$/);
+      if (match) {
+        currentHash = match[1];
+        currentDate = match[2];
+      } else if (currentHash && currentDate && !info.has(line)) {
+        info.set(line, { date: currentDate, hash: currentHash });
+      }
+    }
+  } catch {
+  }
+  return info;
+}
+async function isClean(cwd) {
+  const status = await git(["status", "--porcelain"], cwd);
+  return !status;
+}
+async function assertClean(cwd, subject = "working directory") {
+  if (!await isClean(cwd)) {
+    throw new Error(`${subject} has uncommitted changes. please commit or stash before syncing.`);
+  }
+}
+async function createWorktree(cwd, worktreePath, commitRef) {
+  await git(["worktree", "add", "--detach", worktreePath, commitRef], cwd);
+}
+async function removeWorktree(cwd, worktreePath) {
+  await git(["worktree", "remove", worktreePath, "--force"], cwd, { ignoreErrors: true });
+  await git(["worktree", "prune"], cwd, { ignoreErrors: true });
+}
+async function listWorktrees(cwd) {
+  const output = await git(["worktree", "list", "--porcelain"], cwd);
+  const lines = output.split("\n");
+  const paths = [];
+  for (const line of lines) {
+    if (line.startsWith("worktree ")) {
+      paths.push(line.slice(9));
+    }
+  }
+  return paths;
+}
+async function merge(cwd, ref, options = {}) {
+  const args = ["merge", "--no-ff", ref];
+  if (options.noCommit) args.push("--no-commit");
+  if (options.noEdit) args.push("--no-edit");
+  try {
+    await git(args, cwd, { skipEditor: true });
+    return { success: true, conflicts: [] };
+  } catch (error) {
+    const conflicts = await getConflictedFiles(cwd);
+    if (conflicts.length > 0) {
+      return { success: false, conflicts };
+    }
+    throw error;
+  }
+}
+async function getConflictedFiles(cwd) {
+  const output = await git(["diff", "--name-only", "--diff-filter=U"], cwd, { ignoreErrors: true });
+  if (!output) return [];
+  return output.split("\n").filter(Boolean);
+}
+async function mergeAbort(cwd) {
+  await git(["merge", "--abort"], cwd, { ignoreErrors: true });
+}
+async function fileExistsAtRef(cwd, ref, filePath) {
+  const result = await git(["ls-tree", "--name-only", ref, "--", filePath], cwd, { ignoreErrors: true });
+  return result !== "";
+}
+async function checkoutFromRef(cwd, ref, filePath) {
+  await git(["checkout", ref, "--", filePath], cwd);
+}
+async function restoreWorktreeFromRef(cwd, ref, filePath) {
+  await git(["restore", `--source=${ref}`, "--worktree", "--", filePath], cwd);
+}
+async function getMergeBase(cwd, ref1, ref2) {
+  return git(["merge-base", ref1, ref2], cwd);
+}
+async function getFileChanges(cwd, baseRef, targetRef) {
+  const output = await git(["diff-tree", "-r", "-M90%", "--no-commit-id", baseRef, targetRef], cwd, {
+    ignoreErrors: true
+  });
+  const changes = /* @__PURE__ */ new Map();
+  if (!output) return changes;
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const renameMatch = line.match(/^:\d+ \d+ ([a-f0-9]+) ([a-f0-9]+) R\d*\s+(.+)\t(.+)$/);
+    if (renameMatch) {
+      const [, baseHash, targetHash, oldPath, newPath] = renameMatch;
+      changes.set(newPath, {
+        status: "R",
+        baseHash: baseHash === "0".repeat(40) ? null : baseHash,
+        targetHash: targetHash === "0".repeat(40) ? null : targetHash,
+        oldPath,
+        newPath
+      });
+      continue;
+    }
+    const match = line.match(/^:\d+ \d+ ([a-f0-9]+) ([a-f0-9]+) ([ADMT])\t(.+)$/);
+    if (match) {
+      const [, baseHash, targetHash, status, filePath] = match;
+      changes.set(filePath, {
+        status,
+        baseHash: baseHash === "0".repeat(40) ? null : baseHash,
+        targetHash: targetHash === "0".repeat(40) ? null : targetHash
+      });
+    }
+  }
+  return changes;
+}
+async function getFileHashesAtRef(cwd, ref) {
+  const output = await git(["ls-tree", "-r", ref], cwd);
+  const hashes = /* @__PURE__ */ new Map();
+  if (!output) return hashes;
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const match = line.match(/^\d+ \w+ ([a-f0-9]+)\t(.+)$/);
+    if (match) {
+      const [, hash, filePath] = match;
+      hashes.set(filePath, hash);
+    }
+  }
+  return hashes;
+}
+async function restoreToHead(cwd, filePath) {
+  await git(["checkout", "HEAD", "--", filePath], cwd);
+}
+async function batchRestoreToHead(cwd, filePaths) {
+  if (filePaths.length === 0) return;
+  await git(["checkout", "HEAD", "--", ...filePaths], cwd);
+}
+async function gitRm(cwd, filePath) {
+  await git(["rm", "-f", "--", filePath], cwd, { ignoreErrors: true });
+}
+async function batchGitRm(cwd, filePaths) {
+  if (filePaths.length === 0) return;
+  await git(["rm", "-f", "--", ...filePaths], cwd, { ignoreErrors: true });
+}
+async function getStagedNewFiles(cwd) {
+  const output = await git(["diff", "--cached", "--name-only", "--diff-filter=A"], cwd, { ignoreErrors: true });
+  return output ? output.split("\n").filter(Boolean) : [];
+}
+async function batchUnstageFiles(cwd, filePaths) {
+  if (filePaths.length === 0) return;
+  await git(["rm", "--cached", "-f", "--", ...filePaths], cwd, { ignoreErrors: true });
+}
+async function gitMv(cwd, oldPath, newPath) {
+  const newDir = dirname(join6(cwd, newPath));
+  await mkdir(newDir, { recursive: true });
+  await git(["mv", "-f", oldPath, newPath], cwd);
+}
+async function fileExistsInWorktree(cwd, filePath) {
+  return existsSync4(join6(cwd, filePath));
+}
+async function removeFileFromWorktree(cwd, filePath) {
+  const fullPath = join6(cwd, filePath);
+  try {
+    await unlink(fullPath);
+    await cleanupEmptyParentDirs(cwd, dirname(filePath));
+  } catch {
+  }
+}
+async function removeFileFully(cwd, filePath) {
+  await gitRm(cwd, filePath);
+  await removeFileFromWorktree(cwd, filePath);
+}
+async function cleanupEmptyParentDirs(cwd, relativePath) {
+  if (!relativePath || relativePath === ".") return;
+  const fullPath = join6(cwd, relativePath);
+  try {
+    const entries = await readdir(fullPath);
+    if (entries.length === 0) {
+      await rmdir(fullPath);
+      await cleanupEmptyParentDirs(cwd, dirname(relativePath));
+    }
+  } catch {
+  }
+}
+async function storeLastSyncRef(cwd, upstreamHash) {
+  await git(["update-ref", "refs/cella/last-sync", upstreamHash], cwd);
+  const head = await git(["rev-parse", "HEAD"], cwd, { ignoreErrors: true });
+  if (head) {
+    await git(["update-ref", "refs/cella/last-sync-head", head], cwd);
+  }
+}
+async function stagePath(cwd, path4) {
+  await git(["add", "--", path4], cwd, { ignoreErrors: true });
+}
+async function getStoredSyncRef(cwd) {
+  const ref = await git(["rev-parse", "refs/cella/last-sync"], cwd, { ignoreErrors: true });
+  return ref || null;
+}
+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) {
+  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();
+  } catch {
+    return null;
+  }
+}
+async function commitObjectExists(cwd, sha) {
+  try {
+    await git(["cat-file", "-e", `${sha}^{commit}`], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getRootCommit(cwd, ref) {
+  const out = await git(["rev-list", "--max-parents=0", ref], cwd, { ignoreErrors: true });
+  const roots = out.split("\n").filter(Boolean);
+  return roots.length > 0 ? roots[roots.length - 1] : 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);
+  if (!baseSha) {
+    throw new Error(
+      `no common ancestor between the fork and '${upstreamRef}', and no sync base recorded.
+
+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:
+
+  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);
+  await git(["update-ref", "refs/cella/last-sync", baseSha], cwd);
+}
+async function isAncestor(cwd, ancestor, descendant) {
+  try {
+    await git(["merge-base", "--is-ancestor", ancestor, descendant], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getLegacySyncRef(cwd, headRef) {
+  const storedRef = await getStoredSyncRef(cwd);
+  if (!storedRef) return null;
+  const storedHead = await getStoredSyncHead(cwd);
+  if (storedHead) {
+    const currentHead = await git(["rev-parse", headRef], cwd, { ignoreErrors: true });
+    if (currentHead && currentHead === storedHead) return null;
+  }
+  return storedRef;
+}
+async function getEffectiveMergeBase(cwd, headRef, upstreamRef) {
+  const gitBase = await getMergeBase(cwd, headRef, upstreamRef);
+  const recorded = await readManifestBaseAtRef(cwd, headRef) ?? await getLegacySyncRef(cwd, headRef);
+  if (!recorded) {
+    return { base: gitBase, isStale: false, storedRef: null };
+  }
+  const recordedIsNewer = await isAncestor(cwd, gitBase, recorded);
+  if (recordedIsNewer && recorded !== gitBase) {
+    return { base: recorded, isStale: true, storedRef: recorded };
+  }
+  return { base: gitBase, isStale: false, storedRef: recorded };
+}
+
+// src/utils/cleanup.ts
+var WORKTREE_PREFIXES = {
+  sync: "cella-sync-",
+  view: "cella-view-"
+};
+function buildWorktreePath(kind, repoPath) {
+  return join7(tmpdir(), `${WORKTREE_PREFIXES[kind]}${basename(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;
+function registerWorktree(repoPath, worktreePath) {
+  currentRepoPath = repoPath;
+  currentWorktreePath = worktreePath;
+}
+function unregisterWorktree() {
+  currentRepoPath = null;
+  currentWorktreePath = null;
+}
+async function cleanupWorktree(repoPath, worktreePath) {
+  await removeWorktree(repoPath, worktreePath);
+  if (existsSync5(worktreePath)) {
+    rmSync(worktreePath, { recursive: true, force: true });
+  }
+  unregisterWorktree();
+}
+async function cleanupLeftoverWorktrees(repoPath) {
+  const worktreePath = getWorktreePath(repoPath);
+  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)) && !existsSync5(wt)) {
+      await removeWorktree(repoPath, wt);
+    }
+  }
+}
+async function handleAbort(signal) {
+  console.info();
+  console.info(`${warningMark} Interrupted (${signal}) - cleaning up...`);
+  if (currentRepoPath && currentWorktreePath) {
+    try {
+      await mergeAbort(currentWorktreePath);
+    } catch {
+    }
+    try {
+      await cleanupWorktree(currentRepoPath, currentWorktreePath);
+      console.info(`${colors_default.green("\u2713")} no changes were made to your repository.`);
+    } catch (error) {
+      console.error(
+        `${colors_default.red("\u2717")} failed to clean up worktree: ${error instanceof Error ? error.message : "unknown error"}`
+      );
+    }
+  }
+  process6.exit(1);
+}
+function registerSignalHandlers() {
+  if (cleanupRegistered) return;
+  process6.on("SIGINT", () => handleAbort("SIGINT"));
+  process6.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)...");
+  const [forkHashes, upstreamHashes, baseHashes] = await Promise.all([
+    getFileHashesAtRef(repoPath, localRef),
+    getFileHashesAtRef(repoPath, incomingRef),
+    getFileHashesAtRef(repoPath, mergeBaseRef)
+  ]);
+  const upstreamChanges = await getFileChanges(repoPath, mergeBaseRef, incomingRef);
+  const forkChanges = await getFileChanges(repoPath, mergeBaseRef, localRef);
+  const upstreamRenames = /* @__PURE__ */ new Map();
+  for (const [newPath, change] of upstreamChanges) {
+    if (change.status === "R" && change.oldPath) {
+      upstreamRenames.set(change.oldPath, newPath);
+    }
+  }
+  const allFiles = /* @__PURE__ */ new Set([...forkHashes.keys(), ...upstreamHashes.keys(), ...upstreamRenames.keys()]);
+  const changedFiles = /* @__PURE__ */ new Set([...upstreamChanges.keys(), ...forkChanges.keys(), ...upstreamRenames.keys()]);
+  const upstreamHashSet = new Set(upstreamHashes.values());
+  onProgress?.(
+    `analyzing ${changedFiles.size} changed files (${allFiles.size - changedFiles.size} identical skipped)...`
+  );
+  const analyzedFiles = [];
+  const handledOldPaths = /* @__PURE__ */ new Set();
+  let processed = 0;
+  for (const filePath of allFiles) {
+    if (handledOldPaths.has(filePath)) continue;
+    const inFork = forkHashes.has(filePath);
+    const inUpstream = upstreamHashes.has(filePath);
+    const fileIsIgnored = predicates.isIgnored(filePath);
+    const fileIsPinned = predicates.isPinned(filePath);
+    const upstreamChange = upstreamChanges.get(filePath);
+    const isUpstreamRename = upstreamChange?.status === "R" && upstreamChange.oldPath;
+    const renamedToPath = upstreamRenames.get(filePath);
+    if (!changedFiles.has(filePath) && inFork && inUpstream) {
+      analyzedFiles.push({
+        path: filePath,
+        status: "identical",
+        isIgnored: fileIsIgnored,
+        isPinned: fileIsPinned,
+        existsInFork: true,
+        existsInUpstream: true
+      });
+      continue;
+    }
+    processed++;
+    if (processed % 100 === 0) {
+      onProgress?.(`analyzing ${processed}/${changedFiles.size} changed files...`);
+    }
+    const forkHash = forkHashes.get(filePath) ?? null;
+    const upstreamHash = upstreamHashes.get(filePath) ?? null;
+    const baseHash = baseHashes.get(filePath) ?? null;
+    let status;
+    let renamedFrom;
+    if (isUpstreamRename && upstreamChange.oldPath) {
+      const oldPath = upstreamChange.oldPath;
+      const oldPathInFork = forkHashes.has(oldPath);
+      const forkOldHash = forkHashes.get(oldPath) ?? null;
+      const baseOldHash = baseHashes.get(oldPath) ?? null;
+      handledOldPaths.add(oldPath);
+      const forkModifiedOld = forkOldHash !== baseOldHash;
+      const oldPathPinned = predicates.isPinned(oldPath);
+      if (fileIsPinned || oldPathPinned || predicates.isIgnored(oldPath)) {
+        status = "pinned";
+      } else if (!oldPathInFork) {
+        status = "behind";
+      } else if (forkModifiedOld) {
+        status = "diverged";
+        renamedFrom = oldPath;
+      } else {
+        status = "renamed";
+        renamedFrom = oldPath;
+      }
+      analyzedFiles.push({
+        path: filePath,
+        status,
+        isIgnored: fileIsIgnored,
+        isPinned: fileIsPinned,
+        existsInFork: inFork,
+        existsInUpstream: true,
+        renamedFrom
+      });
+      continue;
+    }
+    if (renamedToPath) {
+      handledOldPaths.add(filePath);
+      continue;
+    }
+    if (fileIsIgnored) {
+      status = "ignored";
+    } else if (!inFork && inUpstream) {
+      const locallyDeleted = baseHash !== null && upstreamHash === baseHash;
+      status = fileIsPinned || locallyDeleted ? "deleted" : "behind";
+    } else if (inFork && !inUpstream) {
+      if (baseHash !== null) {
+        status = fileIsPinned ? "ahead" : "behind";
+      } else {
+        status = forkHash && upstreamHashSet.has(forkHash) ? "behind" : "local";
+      }
+    } else if (forkHash === upstreamHash) {
+      status = "identical";
+    } else {
+      const forkChanged = forkHash !== baseHash;
+      const upstreamChanged = upstreamHash !== baseHash;
+      if (forkChanged && upstreamChanged) {
+        status = fileIsPinned ? "pinned" : "diverged";
+      } else if (forkChanged && !upstreamChanged) {
+        status = fileIsPinned ? "ahead" : predicates.hard ? "behind" : "drifted";
+      } else if (!forkChanged && upstreamChanged) {
+        status = "behind";
+      } else {
+        status = "identical";
+      }
+    }
+    analyzedFiles.push({
+      path: filePath,
+      status,
+      isIgnored: fileIsIgnored,
+      isPinned: fileIsPinned,
+      existsInFork: inFork,
+      existsInUpstream: inUpstream
+    });
+  }
+  return analyzedFiles;
+}
+async function enrichChangeInfo(repoPath, files, mergeBaseRef, localRef, incomingRef) {
+  const forkInfo = await getFileChangeInfo(repoPath, mergeBaseRef, localRef);
+  const upstreamInfo = await getFileChangeInfo(repoPath, mergeBaseRef, incomingRef);
+  for (const file of files) {
+    if (file.status === "identical") continue;
+    if (file.status === "ahead" || file.status === "drifted") {
+      const info = forkInfo.get(file.path);
+      if (info) {
+        file.changedAt = info.date;
+        file.changedCommit = info.hash;
+      }
+    } else if (file.status === "behind") {
+      const info = upstreamInfo.get(file.path);
+      if (info) {
+        file.changedAt = info.date;
+        file.changedCommit = info.hash;
+      }
+    } else if (file.status === "diverged" || file.status === "pinned") {
+      const forkFileInfo = forkInfo.get(file.path);
+      const upstreamFileInfo = upstreamInfo.get(file.path);
+      if (forkFileInfo) {
+        file.changedAt = forkFileInfo.date;
+        file.changedCommit = forkFileInfo.hash;
+      }
+      if (upstreamFileInfo) {
+        file.upstreamChangedAt = upstreamFileInfo.date;
+        file.upstreamCommit = upstreamFileInfo.hash;
+      }
+    }
+  }
+}
+
+// src/services/merge-engine.ts
+function getGitHubBaseUrl(remoteUrl) {
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/([^.]+)(?:\.git)?$/);
+  if (sshMatch) {
+    return `https://github.com/${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  const httpsMatch = remoteUrl.match(/https:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/);
+  if (httpsMatch) {
+    return `https://github.com/${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  return null;
+}
+function syncPredicates(config) {
+  return {
+    isIgnored: (path4) => isIgnored(path4, config),
+    isPinned: (path4) => isPinnedForSync(path4, config, config.unpinned),
+    hard: config.hard
+  };
+}
+async function applyDirectMerge(forkPath, upstreamRef, mergeBaseRef, config, onProgress) {
+  onProgress?.("analyzing files...");
+  const analyzedFiles = await analyzeRefs(
+    forkPath,
+    "HEAD",
+    upstreamRef,
+    mergeBaseRef,
+    syncPredicates(config),
+    onProgress
+  );
+  const batchRestorePaths = [];
+  const batchRemovePaths = [];
+  for (const file of analyzedFiles) {
+    const { path: filePath, status, isPinned: pinned, isIgnored: ignored, existsInFork } = file;
+    if (status === "identical" || status === "ahead") continue;
+    if (ignored && existsInFork) {
+      batchRestorePaths.push(filePath);
+    } else if (ignored && !existsInFork) {
+      batchRemovePaths.push(filePath);
+    } else if (pinned && !file.renamedFrom && existsInFork) {
+      batchRestorePaths.push(filePath);
+    } else if (pinned && !file.renamedFrom && !existsInFork) {
+      batchRemovePaths.push(filePath);
+    }
+  }
+  onProgress?.("starting merge in fork...");
+  await merge(forkPath, upstreamRef, { noCommit: true, noEdit: true });
+  if (batchRestorePaths.length > 0) {
+    onProgress?.(`batch restoring ${batchRestorePaths.length} pinned/ignored files...`);
+    await batchRestoreToHead(forkPath, batchRestorePaths);
+  }
+  if (batchRemovePaths.length > 0) {
+    onProgress?.(`batch removing ${batchRemovePaths.length} ignored files...`);
+    await batchGitRm(forkPath, batchRemovePaths);
+    for (const filePath of batchRemovePaths) {
+      await removeFileFromWorktree(forkPath, filePath);
+    }
+  }
+  for (const file of analyzedFiles) {
+    const { path: filePath, status, isPinned: pinned, isIgnored: ignored, existsInFork } = file;
+    if (status === "identical" || status === "ahead") {
+      continue;
+    }
+    if (ignored) continue;
+    if (pinned && !file.renamedFrom) continue;
+    if (pinned && file.renamedFrom) {
+      const oldPathExists = await fileExistsInWorktree(forkPath, file.renamedFrom);
+      if (oldPathExists) {
+        onProgress?.(`\u2192 ${file.renamedFrom} \u2192 ${filePath}: moving fork content (pinned rename)`);
+        try {
+          await gitMv(forkPath, file.renamedFrom, filePath);
+        } catch {
+          await removeFileFully(forkPath, file.renamedFrom);
+          await checkoutFromRef(forkPath, "HEAD", file.renamedFrom).catch(() => {
+          });
+        }
+      } else {
+        onProgress?.(`\u2192 ${filePath}: keeping fork content (pinned rename, old path removed)`);
+        await restoreToHead(forkPath, filePath);
+      }
+      continue;
+    }
+    if (status === "diverged") {
+      onProgress?.(`\u2192 ${filePath}: using git merge result (diverged)`);
+      continue;
+    }
+    if (status === "behind") {
+      if (!existsInFork) {
+        onProgress?.(`\u2192 ${filePath}: adding from upstream (new file)`);
+        await checkoutFromRef(forkPath, upstreamRef, filePath);
+      } else if (!file.existsInUpstream) {
+        onProgress?.(`\u2192 ${filePath}: removing (deleted in upstream)`);
+        await removeFileFully(forkPath, filePath);
+      } else {
+        onProgress?.(`\u2192 ${filePath}: accepting upstream (behind)`);
+        await checkoutFromRef(forkPath, upstreamRef, filePath);
+      }
+      continue;
+    }
+    if (status === "deleted") {
+      await removeFileFully(forkPath, filePath);
+      continue;
+    }
+    if (status === "renamed" && file.renamedFrom) {
+      const oldPath = file.renamedFrom;
+      const oldPathExists = await fileExistsInWorktree(forkPath, oldPath);
+      const newPathExists = await fileExistsInWorktree(forkPath, filePath);
+      if (oldPathExists && !newPathExists) {
+        onProgress?.(`\u2192 ${oldPath} \u2192 ${filePath}: moving (renamed in upstream)`);
+        try {
+          await gitMv(forkPath, oldPath, filePath);
+        } catch {
+          await removeFileFully(forkPath, oldPath);
+          await checkoutFromRef(forkPath, upstreamRef, filePath);
+        }
+      } else if (oldPathExists && newPathExists) {
+        onProgress?.(`\u2192 ${oldPath} \u2192 ${filePath}: completing rename (removing old)`);
+        await removeFileFully(forkPath, oldPath);
+        await checkoutFromRef(forkPath, upstreamRef, filePath);
+      } else {
+        onProgress?.(`\u2192 ${filePath}: updating from upstream (renamed)`);
+        await checkoutFromRef(forkPath, upstreamRef, filePath);
+      }
+    }
+  }
+  const gitConflicts = await getConflictedFiles(forkPath);
+  for (const filePath of gitConflicts) {
+    const isProtected = isIgnored(filePath, config) || isPinnedForSync(filePath, config, config.unpinned);
+    if (!isProtected) continue;
+    if (await fileExistsAtRef(forkPath, "HEAD", filePath)) {
+      onProgress?.(`\u2192 ${filePath}: keeping fork (protected conflict)`);
+      await restoreToHead(forkPath, filePath);
+    } else {
+      onProgress?.(`\u2192 ${filePath}: removing (protected conflict, not in fork)`);
+      await removeFileFully(forkPath, filePath);
+    }
+  }
+  const remainingConflicts = await getConflictedFiles(forkPath);
+  const remainingConflictSet = new Set(remainingConflicts);
+  const autoMergedFiles = analyzedFiles.filter((file) => file.status === "diverged" && !remainingConflictSet.has(file.path)).map((file) => file.path);
+  const stagedNewFiles = await getStagedNewFiles(forkPath);
+  const staleIgnoredFiles = stagedNewFiles.filter((f) => isIgnored(f, config));
+  if (staleIgnoredFiles.length > 0) {
+    onProgress?.(`cleaning up ${staleIgnoredFiles.length} ignored files still in index...`);
+    await batchUnstageFiles(forkPath, staleIgnoredFiles);
+    for (const filePath of staleIgnoredFiles) {
+      await removeFileFromWorktree(forkPath, filePath);
+    }
+  }
+  return { remainingConflicts, analyzedFiles, autoMergedFiles };
+}
+function calculateSummary(files) {
+  const summary = {
+    managed: 0,
+    identical: 0,
+    ahead: 0,
+    local: 0,
+    drifted: 0,
+    behind: 0,
+    diverged: 0,
+    pinned: 0,
+    ignored: 0,
+    deleted: 0,
+    renamed: 0,
+    total: files.length
+  };
+  for (const file of files) {
+    if (file.status !== "identical" && isManagedFile(file.path)) {
+      summary.managed++;
+      continue;
+    }
+    summary[file.status]++;
+  }
+  return summary;
+}
+function formatLocalCheckoutDetail(forkPath, branch, headSha, changeCount, upstream) {
+  const tracking = upstream.upstream ? `, tracking ${upstream.upstream} (${upstream.ahead} ahead, ${upstream.behind} behind)` : ", no tracking branch";
+  const workingTree = changeCount === 0 ? "  working tree clean" : `  ${changeCount} uncommitted change${changeCount === 1 ? "" : "s"} in working tree, not included in analysis`;
+  return [`${forkPath}`, `  ${branch} @ ${headSha}${tracking}`, workingTree].join("\n");
+}
+async function prepareUpstream(config, onProgress, onStep) {
+  const { forkPath } = config;
+  onProgress?.("checking local checkout...");
+  const [branch, headSha, changeCount, upstreamStatus] = await Promise.all([
+    getCurrentBranch(forkPath),
+    getShortSha(forkPath, "HEAD"),
+    getWorkingTreeChangeCount(forkPath),
+    getUpstreamStatus(forkPath)
+  ]);
+  onStep?.("local checkout", formatLocalCheckoutDetail(forkPath, branch, headSha, changeCount, upstreamStatus));
+  onProgress?.("setting up upstream remote...");
+  const { track: configTrack, branchRef } = resolveUpstream(config.settings);
+  const remoteName = DEFAULT_UPSTREAM_REMOTE;
+  const track = config.track ?? configTrack;
+  await ensureRemote(forkPath, remoteName, config.settings.upstreamUrl);
+  onProgress?.(`fetching upstream (${remoteName})...`);
+  await fetch2(forkPath, remoteName);
+  let upstreamRef = branchRef;
+  let releaseTag;
+  if (track === "release") {
+    await fetchUpstreamTags(forkPath, remoteName);
+    const latest = await resolveLatestReleaseTag(forkPath, remoteName);
+    if (!latest) {
+      throw new Error(
+        `no upstream releases (v*) found on '${remoteName}'. Set upstreamTrack: 'branch' to follow ${branchRef}, or check that ${config.settings.upstreamUrl} publishes release tags.`
+      );
+    }
+    upstreamRef = latest.ref;
+    releaseTag = latest.tag;
+  }
+  config.upstreamRef = upstreamRef;
+  onStep?.("remote configured", `${releaseTag ?? upstreamRef} \u2192 ${config.settings.upstreamUrl}`);
+  onProgress?.("checking sync base...");
+  await ensureSyncBase(forkPath, "HEAD", upstreamRef);
+  const upstreamGitHubUrl = getGitHubBaseUrl(config.settings.upstreamUrl) ?? void 0;
+  const aggressive = config.hard === true || config.unpinned === true;
+  const mergeBase = aggressive ? await getMergeBase(forkPath, "HEAD", upstreamRef) : (await getEffectiveMergeBase(forkPath, "HEAD", upstreamRef)).base;
+  const upstreamCommit = await getCommitInfo(forkPath, upstreamRef);
+  const commitCount = await countCommitsBetween(forkPath, mergeBase, upstreamRef);
+  const commitListMax = 50;
+  const commitSkip = commitCount > commitListMax ? commitCount - commitListMax : 0;
+  const upstreamCommits = commitCount > 0 ? await listCommitsBetween(forkPath, mergeBase, upstreamRef, {
+    oldestFirst: true,
+    skip: commitSkip,
+    limit: commitListMax
+  }) : [];
+  onStep?.("fetched upstream", formatFetchedUpstreamDetail(commitCount, upstreamCommits, upstreamGitHubUrl));
+  return { upstreamRef, releaseTag, mergeBase, upstreamGitHubUrl, upstreamCommit, upstreamCommits };
+}
+function resultMeta(config, ctx) {
+  return {
+    upstreamBranch: config.settings.upstreamBranch ?? "main",
+    upstreamRef: ctx.upstreamRef,
+    upstreamTag: ctx.releaseTag,
+    upstreamGitHubUrl: ctx.upstreamGitHubUrl,
+    upstreamCommit: ctx.upstreamCommit,
+    upstreamCommits: ctx.upstreamCommits
+  };
+}
+async function runSyncMerge(config, ctx, onProgress, onStep) {
+  const { forkPath } = config;
+  const { upstreamRef, releaseTag, mergeBase, upstreamGitHubUrl, upstreamCommit } = ctx;
+  const { remainingConflicts, analyzedFiles, autoMergedFiles } = await applyDirectMerge(
+    forkPath,
+    upstreamRef,
+    mergeBase,
+    config,
+    onProgress
+  );
+  const summary = calculateSummary(analyzedFiles);
+  const synced = analyzedFiles.filter((file) => ["behind", "diverged", "renamed"].includes(file.status)).length;
+  const totalResolved = analyzedFiles.filter(
+    (file) => ["behind", "diverged", "renamed", "ignored", "pinned"].includes(file.status)
+  ).length;
+  const syncManifest = {
+    upstream: {
+      repo: upstreamGitHubUrl ? upstreamGitHubUrl.replace("https://github.com/", "") : void 0,
+      track: releaseTag ? "release" : "branch",
+      commit: upstreamCommit.hash,
+      release: releaseTag ?? null,
+      url: upstreamGitHubUrl ? releaseTag ? `${upstreamGitHubUrl}/releases/tag/${releaseTag}` : `${upstreamGitHubUrl}/commit/${upstreamCommit.hash}` : void 0,
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  const recordSyncPoint = async () => {
+    await storeLastSyncRef(forkPath, upstreamCommit.hash);
+    await writeSyncManifest(forkPath, syncManifest);
+    await stagePath(forkPath, MANIFEST_FILE);
+  };
+  if (remainingConflicts.length > 0) {
+    await recordSyncPoint();
+    onStep?.(
+      "merge in progress",
+      formatMergeInProgressDetail(remainingConflicts.length, autoMergedFiles, { forkPath }, 100)
+    );
+  } else if (totalResolved > 0) {
+    const label = synced > 0 ? `${synced} files from upstream` : "upstream changes";
+    await recordSyncPoint();
+    onStep?.("synced", `${label} (staged, commit to finish)`);
+  } else {
+    await mergeAbort(forkPath);
+    onStep?.("up to date", "no upstream changes to sync");
+  }
+  return {
+    success: remainingConflicts.length === 0,
+    files: analyzedFiles,
+    summary,
+    conflicts: remainingConflicts,
+    autoMergedFiles,
+    ...resultMeta(config, ctx)
+  };
+}
+async function runAnalyzePreview(config, ctx, onProgress, onStep) {
+  const { forkPath } = config;
+  const worktreePath = getWorktreePath(forkPath);
+  onProgress?.("creating worktree in temp directory...");
+  await createWorktree(forkPath, worktreePath, "HEAD");
+  onStep?.("worktree created", worktreePath);
+  onProgress?.("performing merge in worktree...");
+  await merge(worktreePath, ctx.upstreamRef, { noCommit: true, noEdit: true });
+  onStep?.("merge complete", "upstream merged into worktree");
+  onProgress?.("analyzing files...");
+  const analyzedFiles = await analyzeRefs(
+    forkPath,
+    "HEAD",
+    ctx.upstreamRef,
+    ctx.mergeBase,
+    syncPredicates(config),
+    onProgress
+  );
+  await enrichChangeInfo(forkPath, analyzedFiles, ctx.mergeBase, "HEAD", ctx.upstreamRef);
+  onStep?.("analysis complete", `${analyzedFiles.length} files analyzed, dry run \u2014 no changes applied`);
+  onProgress?.("cleaning up worktree...");
+  await cleanupWorktree(forkPath, worktreePath);
+  return {
+    success: true,
+    files: analyzedFiles,
+    summary: calculateSummary(analyzedFiles),
+    // For analyze mode, count diverged files as potential conflicts
+    conflicts: analyzedFiles.filter((f) => f.status === "diverged").map((f) => f.path),
+    ...resultMeta(config, ctx)
+  };
+}
+async function runMergeEngine(config, options) {
+  const { forkPath } = config;
+  const worktreePath = getWorktreePath(forkPath);
+  const { apply, onProgress, onStep } = options;
+  await cleanupLeftoverWorktrees(forkPath);
+  registerWorktree(forkPath, worktreePath);
+  try {
+    const ctx = await prepareUpstream(config, onProgress, onStep);
+    return apply ? await runSyncMerge(config, ctx, onProgress, onStep) : await runAnalyzePreview(config, ctx, onProgress, onStep);
+  } catch (error) {
+    await cleanupWorktree(forkPath, worktreePath);
+    throw error;
+  }
+}
+
+// src/services/analyze.ts
+var scopeStatuses = {
+  all: /* @__PURE__ */ new Set(["ahead", "drifted", "diverged"]),
+  risk: /* @__PURE__ */ new Set(["drifted", "diverged"]),
+  protected: /* @__PURE__ */ new Set(["ahead"])
+};
+function filterByScope(files, scope) {
+  const statuses = scopeStatuses[scope];
+  return files.filter((f) => statuses.has(f.status));
+}
+function findTargetFile(files, targetPath) {
+  const exact = files.find((f) => f.path === targetPath);
+  if (exact) return exact;
+  const normalized = targetPath.replace(/^\.\//, "");
+  return files.find((f) => f.path === normalized);
+}
+function printUnifiedDiff(config, filePath) {
+  const diff = gitDiffFile(config.forkPath, `${config.upstreamRef}..HEAD`, filePath, {
+    dstPrefix: basename2(config.forkPath),
+    color: "never"
+  });
+  writeStdout(diff.toString());
+}
+async function runAnalyze(config) {
+  createSpinner("starting analysis...");
+  const result = await runMergeEngine(config, {
+    apply: false,
+    onProgress: (message) => {
+      spinnerText(message);
+    },
+    onStep: (label, detail) => {
+      spinnerSuccess(label, detail);
+      createSpinner("...");
+    }
+  });
+  spinnerSuccess();
+  const scopedFiles = filterByScope(result.files, config.scope ?? "all");
+  if (config.diff) {
+    const file = findTargetFile(scopedFiles, config.diff) ?? findTargetFile(result.files, config.diff);
+    if (!file) throw new Error(`file not found in analysis results: ${config.diff}`);
+    printUnifiedDiff(config, file.path);
+    return result;
+  }
+  if (config.json) {
+    const out = scopedFiles.map((f) => ({
+      path: f.path,
+      status: f.status,
+      changedAt: f.changedAt ?? null,
+      changedCommit: f.changedCommit ?? null,
+      upstreamChangedAt: f.upstreamChangedAt ?? null,
+      upstreamCommit: f.upstreamCommit ?? null
+    }));
+    writeStdout(JSON.stringify(out, null, 2));
+    return result;
+  }
+  if (config.list) {
+    for (const file of scopedFiles) {
+      console.info(file.path);
+    }
+    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}`);
+    return result;
+  }
+  const linkOptions = {
+    upstreamGitHubUrl: result.upstreamGitHubUrl,
+    upstreamBranch: result.upstreamBranch,
+    fileLinkMode: config.settings.fileLinkMode,
+    upstreamViewPath,
+    forkPath: config.forkPath
+  };
+  printAnalysisFileGroups(result.files, linkOptions);
+  printSummary(result.summary, "analysis summary");
+  if (config.logFile) {
+    const logPath = writeLogFile(config.forkPath, result.files);
+    console.info();
+    console.info(colors_default.dim(`full file list written to: ${logPath}`));
+  }
+  console.info();
+  return result;
+}
+
+// src/services/audit.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { checkbox, confirm, Separator } from "@inquirer/prompts";
+
+// src/utils/audit-utils.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var CACHE_FILE = path.join(import.meta.dirname, "..", "..", ".audit.cache.json");
+var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+var CHANGELOG_PATHS = ["CHANGELOG.md", "CHANGELOG", "changelog.md", "HISTORY.md", "CHANGES.md", "NEWS.md"];
+var DEFAULT_BRANCHES = ["main", "master"];
+function loadCache() {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function saveCache(cache) {
+  try {
+    fs.writeFileSync(CACHE_FILE, `${JSON.stringify(cache, null, 2)}
+`);
+  } catch {
+  }
+}
+function clearCache() {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      fs.unlinkSync(CACHE_FILE);
+      console.info(colors_default.green("\u2713 cache cleared successfully"));
+    } else {
+      console.info(colors_default.yellow("no cache file found"));
+    }
+  } catch (err) {
+    console.error(colors_default.red("failed to clear cache:"), err);
+  }
+}
+async function fetchNpmMetadata(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`);
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function getRepoUrl(data) {
+  if (!data?.repository?.url) return null;
+  let url = data.repository.url;
+  if (url.startsWith("git+")) {
+    url = url.slice(4);
+  }
+  if (url.endsWith(".git")) {
+    url = url.slice(0, -4);
+  }
+  if (url.startsWith("git://")) {
+    url = url.replace("git://", "https://");
+  }
+  return url;
+}
+function isGitHubRepoUrl(repoUrl) {
+  if (!repoUrl) return false;
+  try {
+    const parsed = new URL(repoUrl);
+    return parsed.hostname === "github.com" || parsed.hostname === "www.github.com";
+  } catch {
+    return false;
+  }
+}
+async function findGitHubFile(repoUrl, filePath) {
+  if (!isGitHubRepoUrl(repoUrl)) return null;
+  for (const branch of DEFAULT_BRANCHES) {
+    const rawUrl = repoUrl.replace("github.com", "raw.githubusercontent.com").concat(`/${branch}/${filePath}`);
+    try {
+      const response = await fetch(rawUrl, { method: "HEAD" });
+      if (response.ok) return branch;
+    } catch {
+    }
+  }
+  return null;
+}
+async function findChangelogUrl(repoUrl, packageName, cache) {
+  if (!isGitHubRepoUrl(repoUrl)) return null;
+  const cached = cache[packageName];
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL) {
+    return cached.changelogUrl;
+  }
+  for (const changelogPath of CHANGELOG_PATHS) {
+    const branch = await findGitHubFile(repoUrl, changelogPath);
+    if (branch) {
+      const blobUrl = `${repoUrl}/blob/${branch}/${changelogPath}`;
+      cache[packageName] = {
+        repoUrl,
+        changelogUrl: blobUrl,
+        fetchedAt: Date.now()
+      };
+      return blobUrl;
+    }
+  }
+  cache[packageName] = {
+    repoUrl,
+    changelogUrl: null,
+    fetchedAt: Date.now()
+  };
+  return null;
+}
+function getReleasesUrl(repoUrl) {
+  if (!isGitHubRepoUrl(repoUrl)) return null;
+  return `${repoUrl}/releases`;
+}
+function isMajorVersionChange(current, latest) {
+  const currentMajor = current.split(".")[0]?.replace(/^\D+/, "");
+  const latestMajor = latest.split(".")[0]?.replace(/^\D+/, "");
+  if (!currentMajor || !latestMajor) return false;
+  return Number.parseInt(latestMajor, 10) > Number.parseInt(currentMajor, 10);
+}
+async function getOutdatedPackages(cwd) {
+  try {
+    const { stdout } = await execFileAsync2("pnpm", ["-r", "outdated", "--json"], {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      // 10MB buffer for large outputs
+      cwd
+    });
+    if (!stdout || stdout.trim() === "") {
+      return {};
+    }
+    return JSON.parse(stdout);
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error) {
+      const stdout = error.stdout;
+      if (stdout?.trim()) {
+        try {
+          return JSON.parse(stdout);
+        } catch {
+          return {};
+        }
+      }
+    }
+    return {};
+  }
+}
+async function runPnpmAudit(cwd) {
+  try {
+    const { stdout } = await execFileAsync2("pnpm", ["audit", "--json"], {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      cwd
+    });
+    if (!stdout || stdout.trim() === "") {
+      return null;
+    }
+    return JSON.parse(stdout);
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error) {
+      const stdout = error.stdout;
+      if (stdout?.trim()) {
+        try {
+          return JSON.parse(stdout);
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+}
+function parseDependencyPath(paths) {
+  for (const pathStr of paths) {
+    const parts = pathStr.split(">");
+    if (parts.length >= 2) {
+      return {
+        workspace: parts[0],
+        directDependency: parts.length > 2 ? parts[1] : null
+      };
+    }
+  }
+  return { workspace: null, directDependency: null };
+}
+function buildVulnerabilityMap(auditResult) {
+  const map = /* @__PURE__ */ new Map();
+  if (!auditResult?.advisories) return map;
+  for (const advisory of Object.values(auditResult.advisories)) {
+    const allPaths = advisory.findings?.flatMap((f) => f.paths) || [];
+    const { workspace, directDependency } = parseDependencyPath(allPaths);
+    const existing = map.get(advisory.module_name) || [];
+    existing.push({
+      id: advisory.id,
+      title: advisory.title,
+      severity: advisory.severity,
+      url: advisory.url,
+      vulnerableVersions: advisory.vulnerable_versions,
+      patchedVersions: advisory.patched_versions,
+      cves: advisory.cves || [],
+      workspace,
+      directDependency
+    });
+    map.set(advisory.module_name, existing);
+  }
+  return map;
+}
+function getVulnIcon(severity) {
+  switch (severity) {
+    case "critical":
+      return colors_default.red("\u25CF");
+    case "high":
+      return colors_default.red("\u25CF");
+    case "moderate":
+      return colors_default.yellow("\u25CF");
+    case "low":
+      return colors_default.blue("\u25CF");
+    default:
+      return colors_default.gray("\u25CF");
+  }
+}
+function getHighestSeverity(vulns) {
+  if (vulns.length === 0) return null;
+  const order = ["critical", "high", "moderate", "low", "info"];
+  for (const severity of order) {
+    if (vulns.some((v) => v.severity === severity)) return severity;
+  }
+  return null;
+}
+function middleTruncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  const ellipsis = "\u2026";
+  const charsToShow = maxLen - ellipsis.length;
+  const frontChars = Math.ceil(charsToShow / 2);
+  const backChars = Math.floor(charsToShow / 2);
+  return str.slice(0, frontChars) + ellipsis + str.slice(-backChars);
+}
+function formatDependents(dependents) {
+  if (dependents.length === 0) return "";
+  if (dependents.length === 1) return dependents[0];
+  return `${dependents[0]} +${dependents.length - 1}`;
+}
+
+// src/utils/yaml.ts
+function yamlBlockLines(content, key) {
+  const lines = [];
+  let inBlock = false;
+  for (const line of content.split("\n")) {
+    if (new RegExp(`^${key}:\\s*$`).test(line)) {
+      inBlock = true;
+      continue;
+    }
+    if (!inBlock) continue;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    if (trimmed !== "" && !line.startsWith(" ") && !line.startsWith("	")) break;
+    lines.push(line);
+  }
+  return lines;
+}
+function parseYamlBlockMap(content, key) {
+  const result = {};
+  for (const line of yamlBlockLines(content, key)) {
+    const match = line.match(/^\s+(.+?):\s+['"]?([^'"]+)['"]?\s*$/);
+    if (match) {
+      result[match[1].replace(/^['"]|['"]$/g, "")] = match[2];
+    }
+  }
+  return result;
+}
+function parseYamlBlockList(content, key) {
+  const items = [];
+  for (const line of yamlBlockLines(content, key)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) items.push(trimmed.slice(2).trim());
+  }
+  return items;
+}
+
+// src/services/audit.ts
+async function runAudit(config, options = {}) {
+  const { forkPath } = config;
+  if (options.checkOverrides) {
+    await checkOverrides(forkPath);
+    return;
+  }
+  const spinner = createSpinner("checking for outdated packages & vulnerabilities...");
+  try {
+    if (options.force) {
+      spinnerText("clearing pnpm metadata cache...");
+      clearCache();
+      spawnSync3("pnpm", ["cache", "delete", "*"], {
+        cwd: forkPath,
+        stdio: "ignore"
+      });
+      spinnerText("checking for outdated packages & vulnerabilities...");
+    }
+    const [outdatedPackages, auditResult] = await Promise.all([getOutdatedPackages(forkPath), runPnpmAudit(forkPath)]);
+    const packageNames = Object.keys(outdatedPackages);
+    const vulnMap = buildVulnerabilityMap(auditResult);
+    if (packageNames.length === 0 && vulnMap.size === 0) {
+      spinnerSuccess("all packages are up to date and secure");
+      return;
+    }
+    const cache = loadCache();
+    spinnerText(`found ${packageNames.length} outdated package(s) - fetching metadata...`);
+    const pkgJsonCache = /* @__PURE__ */ new Map();
+    const readDependentPkg = (location) => {
+      let cached = pkgJsonCache.get(location);
+      if (cached === void 0) {
+        try {
+          cached = JSON.parse(fs2.readFileSync(path2.join(location, "package.json"), "utf-8"));
+        } catch {
+          cached = null;
+        }
+        pkgJsonCache.set(location, cached ?? null);
+      }
+      return cached ?? null;
+    };
+    const dependentNameCache = /* @__PURE__ */ new Map();
+    for (const name of packageNames) {
+      for (const dep of outdatedPackages[name].dependentPackages) {
+        if (!dependentNameCache.has(dep.location)) {
+          dependentNameCache.set(dep.location, readDependentPkg(dep.location)?.name || path2.basename(dep.location));
+        }
+      }
+    }
+    const enhancedPackages = [];
+    const batchSize = 10;
+    for (let i = 0; i < packageNames.length; i += batchSize) {
+      const batch = packageNames.slice(i, i + batchSize);
+      const results = await Promise.all(
+        batch.map(async (name) => {
+          const pkg = outdatedPackages[name];
+          const metadata = await fetchNpmMetadata(name);
+          const repoUrl = getRepoUrl(metadata);
+          const changelogUrl = await findChangelogUrl(repoUrl, name, cache);
+          const pinnedIn = [];
+          for (const d of pkg.dependentPackages) {
+            const spec = readDependentPkg(d.location)?.[pkg.dependencyType]?.[name] || "";
+            if (spec && !spec.startsWith("^") && !spec.startsWith("~") && !spec.startsWith(">")) {
+              pinnedIn.push(d.name);
+            }
+          }
+          return {
+            name,
+            current: pkg.current,
+            latest: pkg.latest,
+            dependents: pkg.dependentPackages.map((d) => d.name),
+            dependentLocations: pkg.dependentPackages.map((d) => d.location),
+            isDev: pkg.dependencyType === "devDependencies",
+            isMajorUpdate: isMajorVersionChange(pkg.current, pkg.latest),
+            pinnedIn,
+            repoUrl,
+            changelogUrl,
+            releasesUrl: getReleasesUrl(repoUrl),
+            vulnerabilities: vulnMap.get(name) || []
+          };
+        })
+      );
+      enhancedPackages.push(...results);
+    }
+    saveCache(cache);
+    enhancedPackages.sort((a, b) => {
+      const depA = formatDependents(a.dependents);
+      const depB = formatDependents(b.dependents);
+      const depCompare = depA.localeCompare(depB);
+      if (depCompare !== 0) return depCompare;
+      return a.name.localeCompare(b.name);
+    });
+    spinner.stop();
+    if (enhancedPackages.length > 0) {
+      printOutdatedResults(enhancedPackages, dependentNameCache, forkPath);
+    }
+    printVulnerabilityResults(auditResult, vulnMap);
+    const hasVulns = vulnMap.size > 0;
+    if ((enhancedPackages.length > 0 || hasVulns) && !config.list) {
+      await promptForUpdates(enhancedPackages, forkPath, auditResult);
+    }
+  } finally {
+    spinner.stop();
+  }
+}
+function printOutdatedResults(enhancedPackages, dependentNameCache, forkPath) {
+  const DEV_TAG = " (dev)";
+  const MAX_NAME_LEN = 35;
+  const MAX_DEPENDENTS_LEN = 15;
+  const maxNameLen = Math.min(
+    MAX_NAME_LEN,
+    Math.max(7, ...enhancedPackages.map((p) => p.name.length + (p.isDev ? DEV_TAG.length : 0)))
+  );
+  const maxCurrentLen = Math.max(7, ...enhancedPackages.map((p) => p.current.length));
+  const maxLatestLen = Math.max(6, ...enhancedPackages.map((p) => p.latest.length));
+  const maxDependentsLen = Math.min(
+    MAX_DEPENDENTS_LEN,
+    Math.max(10, ...enhancedPackages.map((p) => formatDependents(p.dependents).length))
+  );
+  const header = [
+    " ",
+    colors_default.bold("package".padEnd(maxNameLen)),
+    colors_default.bold("current".padEnd(maxCurrentLen)),
+    colors_default.bold("latest".padEnd(maxLatestLen)),
+    colors_default.bold("in".padEnd(maxDependentsLen)),
+    colors_default.bold("links")
+  ].join(" ");
+  console.info(header);
+  for (const pkg of enhancedPackages) {
+    const highestSeverity = getHighestSeverity(pkg.vulnerabilities);
+    const vulnIndicator = highestSeverity ? getVulnIcon(highestSeverity) : " ";
+    const fullName = pkg.isDev ? `${pkg.name}${DEV_TAG}` : pkg.name;
+    const displayName = middleTruncate(fullName, maxNameLen);
+    const name = colors_default.white(displayName.padEnd(maxNameLen));
+    const current = colors_default.red(pkg.current.padEnd(maxCurrentLen));
+    const latestText = pkg.latest.padEnd(maxLatestLen);
+    const latest = pkg.isMajorUpdate ? colors_default.bold(colors_default.green(latestText)) : colors_default.green(latestText);
+    const dependentsText = formatDependents(pkg.dependents);
+    const dependents = colors_default.dim(middleTruncate(dependentsText, maxDependentsLen).padEnd(maxDependentsLen));
+    const links = [];
+    if (pkg.changelogUrl) {
+      links.push(hyperlink(colors_default.magenta("log"), pkg.changelogUrl));
+    }
+    if (pkg.releasesUrl) {
+      links.push(hyperlink(colors_default.blue("rel"), pkg.releasesUrl));
+    }
+    if (pkg.repoUrl) {
+      links.push(hyperlink(colors_default.cyan("repo"), pkg.repoUrl));
+    }
+    const linksStr = links.length > 0 ? links.join(" ") : colors_default.dim("n/a");
+    console.info(`${vulnIndicator} ${name} ${current} ${latest} ${dependents} ${linksStr}`);
+  }
+  console.info();
+  const dependentMap = /* @__PURE__ */ new Map();
+  for (const pkg of enhancedPackages) {
+    for (const loc of pkg.dependentLocations) {
+      const dependentName = dependentNameCache.get(loc) || path2.basename(loc);
+      const existing = dependentMap.get(dependentName);
+      if (existing) {
+        existing.count++;
+      } else {
+        dependentMap.set(dependentName, { location: loc, count: 1 });
+      }
+    }
+  }
+  const sortedDependents = [...dependentMap.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  const maxDependentNameLen = Math.max(0, ...sortedDependents.map(([name]) => name.length));
+  for (const [dependentName, { location, count }] of sortedDependents) {
+    const packageJsonPath = path2.join(location, "package.json");
+    const relativePath = path2.relative(forkPath, packageJsonPath);
+    const paddedName = dependentName.padEnd(maxDependentNameLen);
+    console.info(
+      `  ${colors_default.dim("\u2022")} ${paddedName}  ${hyperlink(relativePath, `file://${packageJsonPath}`)} ${colors_default.dim(`${count}`)}`
+    );
+  }
+}
+async function promptForUpdates(packages, forkPath, auditResult) {
+  const hasVulnerabilities = auditResult !== null && Object.values(auditResult.metadata?.vulnerabilities || {}).some((c) => c > 0);
+  const hasPackages = packages.length > 0;
+  let confirmMessage = "update packages?";
+  if (hasVulnerabilities && hasPackages) {
+    confirmMessage = "update packages and fix vulnerabilities?";
+  } else if (hasVulnerabilities) {
+    confirmMessage = "fix vulnerabilities?";
+  }
+  let wantsUpdate;
+  try {
+    wantsUpdate = await confirm({
+      message: confirmMessage,
+      default: true
+    });
+  } catch {
+    return;
+  }
+  if (!wantsUpdate) return;
+  console.info();
+  const makeChoice = (pkg) => {
+    const devTag = pkg.isDev ? colors_default.dim(" (dev)") : "";
+    const version = `${colors_default.red(pkg.current)} \u2192 ${colors_default.green(pkg.latest)}`;
+    const pinnedWarning = pkg.pinnedIn.length > 0 ? `  ${warningMark} ${colors_default.dim(`pinned in ${pkg.pinnedIn.join(", ")}`)}` : "";
+    return {
+      name: `${pkg.name}${devTag}  ${version}${pinnedWarning}`,
+      value: pkg.name,
+      checked: false
+    };
+  };
+  const AUDIT_FIX_VALUE = "__audit_fix__";
+  const pinned = packages.filter((p) => p.pinnedIn.length > 0);
+  const regular = packages.filter((p) => p.pinnedIn.length === 0);
+  const choices = [];
+  if (hasVulnerabilities) {
+    const vulnMeta = auditResult?.metadata?.vulnerabilities || {};
+    const parts = [];
+    if (vulnMeta.critical) parts.push(colors_default.red(`${vulnMeta.critical} critical`));
+    if (vulnMeta.high) parts.push(colors_default.red(`${vulnMeta.high} high`));
+    if (vulnMeta.moderate) parts.push(colors_default.yellow(`${vulnMeta.moderate} moderate`));
+    if (vulnMeta.low) parts.push(colors_default.blue(`${vulnMeta.low} low`));
+    const vulnSummary = parts.length > 0 ? ` ${colors_default.dim("\xB7")} ${parts.join(" ")}` : "";
+    choices.push(new Separator(colors_default.red(`\u2500\u2500 vulnerabilities${vulnSummary} \u2500\u2500`)));
+    choices.push({
+      name: `${colors_default.cyan("pnpm audit --fix override")}  ${colors_default.dim("add overrides for non-vulnerable versions")}`,
+      value: AUDIT_FIX_VALUE,
+      checked: false
+    });
+  }
+  if (pinned.length > 0) {
+    choices.push(new Separator(colors_default.yellow(`\u2500\u2500 pinned (${pinned.length}) \u2500\u2500`)));
+    choices.push(...pinned.map(makeChoice));
+  }
+  if (regular.length > 0) {
+    if (pinned.length > 0 || hasVulnerabilities) {
+      choices.push(new Separator(colors_default.dim(`\u2500\u2500 packages (${regular.length}) \u2500\u2500`)));
+    }
+    choices.push(...regular.map(makeChoice));
+  }
+  let selected;
+  try {
+    selected = await checkbox({
+      message: "toggle packages to update",
+      choices,
+      required: true,
+      pageSize: 20,
+      loop: false,
+      theme: {
+        icon: {
+          cursor: "\u276F "
+        },
+        style: {
+          highlight: (text) => text,
+          keysHelpTip: (keys) => {
+            const tips = keys.map(([key, action]) => `${colors_default.dim(key)} ${action}`);
+            return tips.join("  ");
+          },
+          renderSelectedChoices: (selectedChoices) => colors_default.dim(`${selectedChoices.length} package${selectedChoices.length !== 1 ? "s" : ""} selected`)
+        }
+      }
+    });
+  } catch {
+    return;
+  }
+  const runAuditFix = selected.includes(AUDIT_FIX_VALUE);
+  const selectedPackages = selected.filter((s) => s !== AUDIT_FIX_VALUE);
+  const summaryParts = [];
+  if (selectedPackages.length > 0) {
+    summaryParts.push(`updating ${selectedPackages.length} package${selectedPackages.length !== 1 ? "s" : ""}`);
+  }
+  if (runAuditFix) {
+    summaryParts.push("then updating dependencies");
+  }
+  console.info();
+  console.info(colors_default.green(`\u2713 ${summaryParts.join(" ")}`));
+  console.info();
+  const selectedMajor = packages.filter((p) => selectedPackages.includes(p.name) && p.isMajorUpdate);
+  if (selectedMajor.length > 0) {
+    const majorNames = selectedMajor.map((p) => colors_default.bold(p.name)).join(", ");
+    try {
+      const proceed = await confirm({
+        message: `${selectedMajor.length} major update${selectedMajor.length > 1 ? "s" : ""} selected (${majorNames}). proceed?`,
+        default: true
+      });
+      if (!proceed) {
+        console.info(colors_default.dim("  update cancelled"));
+        return;
+      }
+    } catch {
+      return;
+    }
+  }
+  const catalogPackages = readCatalogPackageNames(forkPath);
+  const workspacePackages = /* @__PURE__ */ new Map();
+  for (const pkgName of selectedPackages) {
+    const pkg = packages.find((p) => p.name === pkgName);
+    if (!pkg) continue;
+    for (let i = 0; i < pkg.dependents.length; i++) {
+      const dependent = pkg.dependents[i];
+      if (!workspacePackages.has(dependent)) {
+        workspacePackages.set(dependent, { packages: [] });
+      }
+      workspacePackages.get(dependent)?.packages.push(pkgName);
+    }
+  }
+  if (runAuditFix) {
+    console.info(colors_default.dim("running pnpm audit --fix override..."));
+    const auditFixResult = spawnSync3("pnpm", ["audit", "--fix", "override"], {
+      cwd: forkPath,
+      stdio: "inherit"
+    });
+    console.info();
+    if (auditFixResult.status === 0) {
+      console.info(colors_default.green("\u2713 pnpm audit --fix override completed"));
+    } else {
+      console.error(colors_default.red(`\u2717 pnpm audit --fix override failed (exit code ${auditFixResult.status})`));
+    }
+  }
+  for (const [workspace, { packages: pkgs }] of workspacePackages) {
+    const pkgList = pkgs.join(", ");
+    console.info(`${colors_default.cyan("\u2191")} ${colors_default.bold(workspace)}: ${colors_default.dim(pkgList)}`);
+  }
+  if (selectedPackages.length > 0) {
+    console.info();
+    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], {
+        cwd: forkPath,
+        stdio: "inherit"
+      });
+      console.info();
+      if (normalizeResult.status !== 0) {
+        console.error(colors_default.red(`\u2717 catalog normalization failed (exit code ${normalizeResult.status})`));
+        return;
+      }
+    }
+    const result = spawnSync3("pnpm", ["-r", "up", "--latest", ...selectedPackages], {
+      cwd: forkPath,
+      stdio: "inherit"
+    });
+    console.info();
+    if (result.status === 0) {
+      console.info(colors_default.green(`\u2713 ${selectedPackages.length} package${selectedPackages.length > 1 ? "s" : ""} updated`));
+    } else {
+      console.error(colors_default.red(`\u2717 update failed (exit code ${result.status})`));
+    }
+  }
+}
+function printVulnerabilityResults(auditResult, vulnMap) {
+  if (auditResult && vulnMap.size > 0) {
+    const vulnMeta = auditResult.metadata?.vulnerabilities || {};
+    const criticalCount = vulnMeta.critical || 0;
+    const highCount = vulnMeta.high || 0;
+    const moderateCount = vulnMeta.moderate || 0;
+    const lowCount = vulnMeta.low || 0;
+    console.info();
+    console.info(
+      `${colors_default.red("\u26A0")} ${colors_default.bold("vulnerabilities")} ${colors_default.dim("\xB7")} ` + (criticalCount > 0 ? colors_default.red(`${criticalCount} critical `) : "") + (highCount > 0 ? colors_default.red(`${highCount} high `) : "") + (moderateCount > 0 ? colors_default.yellow(`${moderateCount} moderate `) : "") + (lowCount > 0 ? colors_default.blue(`${lowCount} low`) : "")
+    );
+    console.info("\u2500".repeat(60));
+    for (const [pkgName, vulns] of vulnMap.entries()) {
+      for (const vuln of vulns) {
+        const severityIcon = getVulnIcon(vuln.severity);
+        const cveStr = vuln.cves.length > 0 ? colors_default.dim(` ${vuln.cves[0]}`) : "";
+        let sourceStr = "";
+        if (vuln.workspace) {
+          sourceStr = colors_default.dim(` in ${vuln.workspace}`);
+          if (vuln.directDependency) {
+            sourceStr += colors_default.dim(` via ${vuln.directDependency}`);
+          }
+        }
+        const title = middleTruncate(vuln.title, 60);
+        console.info(
+          `${severityIcon} ${colors_default.white(pkgName)} ${colors_default.dim(vuln.vulnerableVersions)}${sourceStr} ${colors_default.dim("\xB7")} ${title}${cveStr}`
+        );
+      }
+    }
+  } else {
+    console.info();
+    console.info(`${colors_default.green("\u2713")} no vulnerabilities found`);
+  }
+  console.info();
+}
+function readCatalogPackageNames(forkPath) {
+  const workspacePath = path2.join(forkPath, "pnpm-workspace.yaml");
+  try {
+    const content = fs2.readFileSync(workspacePath, "utf-8");
+    return new Set(Object.keys(parseYamlBlockMap(content, "catalog")));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function readOverrides(forkPath) {
+  const overrides = /* @__PURE__ */ new Map();
+  const pkgJsonPath = path2.join(forkPath, "package.json");
+  try {
+    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    const pnpmOverrides = pkgJson.pnpm?.overrides || {};
+    for (const [key, value] of Object.entries(pnpmOverrides)) {
+      overrides.set(key, { target: value, source: "package.json" });
+    }
+  } catch {
+  }
+  const workspacePath = path2.join(forkPath, "pnpm-workspace.yaml");
+  try {
+    const content = fs2.readFileSync(workspacePath, "utf-8");
+    const wsOverrides = parseYamlBlockMap(content, "overrides");
+    for (const [key, value] of Object.entries(wsOverrides)) {
+      overrides.set(key, { target: value, source: "pnpm-workspace.yaml" });
+    }
+  } catch {
+  }
+  return overrides;
+}
+async function checkOverrides(forkPath) {
+  const spinner = createSpinner("checking overrides against current audit...");
+  const overrides = readOverrides(forkPath);
+  if (overrides.size === 0) {
+    spinnerSuccess("no pnpm.overrides found");
+    return;
+  }
+  const auditResult = await runPnpmAudit(forkPath);
+  const activeAdvisoryPackages = /* @__PURE__ */ new Set();
+  if (auditResult?.advisories) {
+    for (const advisory of Object.values(auditResult.advisories)) {
+      activeAdvisoryPackages.add(advisory.module_name);
+    }
+  }
+  spinner.stop();
+  const securityOverrides = [];
+  const pinOverrides = [];
+  for (const [key, { target, source }] of overrides) {
+    const atIndex = key.indexOf("@", key.startsWith("@") ? 1 : 0);
+    if (atIndex > 0) {
+      const pkg = key.slice(0, atIndex);
+      const hasActiveAdvisory = activeAdvisoryPackages.has(pkg);
+      const status = hasActiveAdvisory ? "active" : "likely stale";
+      securityOverrides.push({ key, pkg, target, source, status });
+    } else {
+      pinOverrides.push({ key, target, source });
+    }
+  }
+  const allKeys = Array.from(overrides.keys());
+  const allValues = Array.from(overrides.values());
+  const maxKeyLen = Math.max(8, ...allKeys.map((k) => k.length));
+  const maxTargetLen = Math.max(6, ...allValues.map((v) => v.target.length));
+  if (securityOverrides.length > 0) {
+    console.info(colors_default.bold(`security overrides (${securityOverrides.length})`));
+    console.info("\u2500".repeat(60));
+    for (const o of securityOverrides) {
+      const icon = o.status === "active" ? colors_default.red("\u25CF") : colors_default.green("\u25CB");
+      const statusText = o.status === "active" ? colors_default.red("active") : colors_default.green("likely stale");
+      const keyText = colors_default.white(o.key.padEnd(maxKeyLen));
+      const targetText = colors_default.dim(o.target.padEnd(maxTargetLen));
+      const sourceText = colors_default.dim(o.source);
+      console.info(`  ${icon} ${keyText} \u2192 ${targetText} ${statusText}  ${sourceText}`);
+    }
+    console.info();
+  }
+  if (pinOverrides.length > 0) {
+    console.info(colors_default.bold(`version pins (${pinOverrides.length})`));
+    console.info("\u2500".repeat(60));
+    for (const o of pinOverrides) {
+      const keyText = colors_default.white(o.key.padEnd(maxKeyLen));
+      const targetText = colors_default.dim(o.target.padEnd(maxTargetLen));
+      const sourceText = colors_default.dim(o.source);
+      console.info(`  ${colors_default.blue("\u25C6")} ${keyText} \u2192 ${targetText}  ${sourceText}`);
+    }
+    console.info();
+  }
+  const staleCount = securityOverrides.filter((o) => o.status === "likely stale").length;
+  const activeCount = securityOverrides.filter((o) => o.status === "active").length;
+  if (staleCount > 0) {
+    console.info(
+      `${colors_default.green("\u25CB")} ${staleCount} override${staleCount !== 1 ? "s" : ""} likely stale \u2014 no matching advisory found in current audit`
+    );
+    console.info(colors_default.dim("  overrides mask vulnerabilities \u2014 verify by temporarily removing and running pnpm audit"));
+  }
+  if (activeCount > 0) {
+    console.info(
+      `${colors_default.red("\u25CF")} ${activeCount} override${activeCount !== 1 ? "s" : ""} still active \u2014 advisory present without override`
+    );
+  }
+  if (pinOverrides.length > 0) {
+    console.info(
+      `${colors_default.blue("\u25C6")} ${pinOverrides.length} version pin${pinOverrides.length !== 1 ? "s" : ""} \u2014 not security-related, review manually`
+    );
+  }
+  console.info();
+}
+
+// src/services/contributions.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join12 } from "path";
+import {
+  createPrompt,
+  isDownKey,
+  isEnterKey,
+  isSpaceKey,
+  isUpKey,
+  useKeypress,
+  useMemo,
+  usePagination,
+  useState
+} from "@inquirer/core";
+import { select as select2 } from "@inquirer/prompts";
+
+// src/services/contrib-core.ts
+import { dirname as dirname2, join as join11 } 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));
+}
+async function detectContributableFiles(repoPath, baseRef, forkRef, config, forkTerritory = []) {
+  const mergeBase = (await git(["merge-base", baseRef, forkRef], repoPath, { ignoreErrors: true })).trim() || baseRef;
+  const predicates = {
+    isIgnored: (path4) => isIgnored(path4, config) || isUnderAnyFolder(path4, forkTerritory),
+    isPinned: (path4) => isPinned(path4, config)
+  };
+  const analyzed = await analyzeRefs(repoPath, baseRef, forkRef, mergeBase, predicates);
+  await enrichChangeInfo(repoPath, analyzed, mergeBase, baseRef, forkRef);
+  const baseFiles = await listFilesAtRef(repoPath, baseRef);
+  const baseDirs = /* @__PURE__ */ new Set(["."]);
+  for (const f of baseFiles) {
+    let dir = dirname2(f);
+    while (dir !== ".") {
+      baseDirs.add(dir);
+      dir = dirname2(dir);
+    }
+  }
+  const files = [];
+  for (const file of analyzed) {
+    if (file.status !== "behind" && file.status !== "diverged") continue;
+    if (file.isIgnored || file.isPinned) continue;
+    const inCella = file.existsInFork;
+    const inFork = file.existsInUpstream;
+    let kind;
+    if (inCella && !inFork) {
+      kind = "deleted";
+    } else if (!inCella && inFork) {
+      if (!baseDirs.has(dirname2(file.path))) continue;
+      kind = "created";
+    } else {
+      kind = "modified";
+    }
+    const changedAt = file.status === "diverged" ? file.upstreamChangedAt : file.changedAt;
+    files.push({ path: file.path, kind, status: file.status, changedAt });
+  }
+  return {
+    modified: files.filter((f) => f.kind === "modified").map((f) => f.path),
+    created: files.filter((f) => f.kind === "created").map((f) => f.path),
+    deleted: files.filter((f) => f.kind === "deleted").map((f) => f.path),
+    files
+  };
+}
+function countDetection(detection) {
+  return detection.modified.length + detection.created.length + detection.deleted.length;
+}
+async function readBlobInfo(repoPath, ref, filePath) {
+  const line = await git(["ls-tree", ref, "--", filePath], repoPath, { ignoreErrors: true });
+  if (!line) return null;
+  const match = line.match(/^(\d{6}) (\w+) ([0-9a-f]+)\t/);
+  if (!match) return null;
+  const [, mode, type, hash] = match;
+  if (type !== "blob") return null;
+  if (mode !== "100644" && mode !== "100755") return null;
+  return { mode, hash };
+}
+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 indexEnv = { GIT_INDEX_FILE: tmpIndex };
+  try {
+    await git(["read-tree", baseRef], repoPath, { env: indexEnv });
+    const appliedFiles = [];
+    for (const filePath of [...detection.modified, ...detection.created]) {
+      const blob = await readBlobInfo(repoPath, forkRef, filePath);
+      if (!blob) continue;
+      await git(
+        ["update-index", "--add", "--replace", "--cacheinfo", `${blob.mode},${blob.hash},${filePath}`],
+        repoPath,
+        {
+          env: indexEnv
+        }
+      );
+      appliedFiles.push(filePath);
+    }
+    for (const filePath of detection.deleted) {
+      await git(["update-index", "--remove", filePath], repoPath, { env: indexEnv, ignoreErrors: true });
+      appliedFiles.push(`(deleted) ${filePath}`);
+    }
+    if (appliedFiles.length === 0) {
+      return { branch, appliedFiles };
+    }
+    const treeHash = await git(["write-tree"], repoPath, { env: indexEnv });
+    const parentHash = await git(["rev-parse", baseRef], repoPath);
+    const commitBody = appliedFiles.map((f) => `- ${f}`).join("\n");
+    const commitMessage = `contrib(${forkName}): ${appliedFiles.length} files
+
+${commitBody}`;
+    const commitHash = await git(["commit-tree", treeHash, "-p", parentHash, "-m", commitMessage], repoPath);
+    await git(["update-ref", `refs/heads/${branch}`, commitHash], repoPath);
+    return { branch, appliedFiles };
+  } finally {
+    try {
+      const { unlinkSync: unlinkSync2 } = await import("fs");
+      unlinkSync2(tmpIndex);
+    } catch {
+    }
+  }
+}
+
+// src/services/fork-utils.ts
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve4 } from "path";
+function validateForkPath(fork, basePath, requireConfig = false) {
+  const resolvedPath = resolve4(basePath, fork.localPath);
+  if (!resolvedPath.startsWith(resolve4(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`)) {
+    return { fork, resolvedPath, valid: false, error: "missing cella.config.ts" };
+  }
+  return { fork, resolvedPath, valid: true };
+}
+function printNoForksHint(action) {
+  console.info(colors_default.yellow("no forks configured in cella.config.ts"));
+  console.info(colors_default.dim(action));
+  console.info(colors_default.dim(`  forks: [{ name: 'my-app', localPath: '../my-app', pullBranch: 'development' }]`));
+}
+
+// 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);
+}
+function shouldApplyContributionsUnstaged(repoPath) {
+  return JSON.parse(readFileSync4(join12(repoPath, "package.json"), "utf8")).name === "cella";
+}
+var contribPrompt = createPrompt((config, done) => {
+  const { pageSize = 20, baseRef, cwd, forkName } = config;
+  const [items, setItems] = useState(config.items);
+  const [active, setActive] = useState(0);
+  const [statusMsg, setStatusMsg] = useState("");
+  const [promptStatus, setPromptStatus] = useState("idle");
+  const bounds = useMemo(() => {
+    if (items.length === 0) return { first: 0, last: 0 };
+    return { first: 0, last: items.length - 1 };
+  }, [items]);
+  useKeypress(async (key) => {
+    if (items.length === 0) {
+      if (isEnterKey(key) || key.name === "q") {
+        setPromptStatus("done");
+        done([]);
+      }
+      return;
+    }
+    if (key.name === "q") {
+      setPromptStatus("done");
+      done([]);
+      return;
+    }
+    if (isEnterKey(key)) {
+      const selected = items.filter((i) => i.checked);
+      if (selected.length === 0) {
+        setStatusMsg("select files with space first, or q to quit");
+        return;
+      }
+      setPromptStatus("done");
+      done(selected);
+      return;
+    }
+    if (key.ctrl && isUpKey(key)) {
+      setActive(bounds.first);
+      setStatusMsg("");
+      return;
+    }
+    if (key.ctrl && isDownKey(key)) {
+      setActive(bounds.last);
+      setStatusMsg("");
+      return;
+    }
+    if (isUpKey(key)) {
+      setActive(active <= bounds.first ? bounds.first : active - 1);
+      setStatusMsg("");
+      return;
+    }
+    if (isDownKey(key)) {
+      setActive(active >= bounds.last ? bounds.last : active + 1);
+      setStatusMsg("");
+      return;
+    }
+    if (isSpaceKey(key)) {
+      setItems(items.map((item, i) => i === active ? { ...item, checked: !item.checked } : item));
+      return;
+    }
+    if (key.name === "d") {
+      showContribDiff(items[active], baseRef, cwd, forkName);
+      setStatusMsg(`viewed ${items[active].path}`);
+      return;
+    }
+    if (key.name === "a") {
+      const allChecked = items.every((item) => item.checked);
+      setItems(items.map((item) => ({ ...item, checked: !allChecked })));
+      setStatusMsg(allChecked ? "deselected all" : "selected all");
+      return;
+    }
+  });
+  if (promptStatus === "done") {
+    const checked = items.filter((i) => i.checked);
+    if (checked.length > 0) {
+      return `${colors_default.green("\u2713")} ${checked.length} files accepted`;
+    }
+    return `${colors_default.green("\u2713")} done`;
+  }
+  if (items.length === 0) {
+    return `${colors_default.green("\u2713")} no contributions \u2014 press enter`;
+  }
+  const checkedCount = items.filter((i) => i.checked).length;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      const checkbox2 = item.checked ? colors_default.green("\u25CF") : colors_default.dim("\u25CB");
+      const cursor = isActive ? colors_default.cyan("\u276F") : " ";
+      const newLabel = item.created ? colors_default.yellow(" \xB7 not in cella") : "";
+      const delLabel = item.deleted ? colors_default.yellow(" [del]") : "";
+      const statusTag = item.status === "diverged" ? colors_default.yellow(" \u26A0 diverged") : "";
+      const dateLabel = item.changedAt ? colors_default.dim(` \xB7 ${item.changedAt}`) : "";
+      const line = `${cursor} ${checkbox2} ${item.path}${delLabel}${statusTag}${newLabel}${dateLabel}`;
+      return isActive ? colors_default.cyan(line) : line;
+    },
+    pageSize,
+    loop: false
+  });
+  const countInfo = checkedCount > 0 ? `${items.length} files, ${colors_default.green(`${checkedCount} selected`)}` : `${items.length} files`;
+  const header = `${colors_default.cyan("\u2B07")} ${config.message} ${colors_default.dim(`(${countInfo})`)}`;
+  const keys = [
+    ["\u2191\u2193", "navigate"],
+    ["d", "diff"],
+    ["a", "(de)select all"],
+    ["space", "select"],
+    ["\u23CE", "accept"],
+    ["q", "quit"]
+  ];
+  const helpLine = keys.map(([k, a]) => `${colors_default.bold(k)} ${colors_default.dim(a)}`).join(colors_default.dim(" \xB7 "));
+  const statusLine = statusMsg ? `  ${colors_default.dim(statusMsg)}` : "";
+  const lines = [header, page, statusLine, helpLine].filter(Boolean).join("\n").trimEnd();
+  return `${lines}\x1B[?25l`;
+});
+async function fetchForkBranch(cellaPath, fetchSource, pullBranch) {
+  await git(["fetch", fetchSource, pullBranch], cellaPath);
+  return git(["rev-parse", "FETCH_HEAD"], cellaPath);
+}
+async function forkRefMeta(cellaPath, forkRef) {
+  const out = await git(["log", "-1", "--format=%h%x09%cr", forkRef], cellaPath, { ignoreErrors: true });
+  const [sha = forkRef.slice(0, 7), date = "unknown"] = out.split("	");
+  return { sha, date };
+}
+async function diffStat(cellaPath, baseRef, ref) {
+  const out = await git(["diff", "--numstat", `${baseRef}..${ref}`], cellaPath, { ignoreErrors: true });
+  const stat = /* @__PURE__ */ new Map();
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const [a, d, ...rest] = line.split("	");
+    const path4 = rest.join("	");
+    if (!path4) continue;
+    stat.set(path4, {
+      additions: a === "-" ? null : Number(a),
+      deletions: d === "-" ? null : Number(d)
+    });
+  }
+  return stat;
+}
+async function runContributions(config) {
+  const forks = config.forks ?? [];
+  if (forks.length === 0) {
+    printNoForksHint("add forks to pull contributions from:");
+    return;
+  }
+  const baseRef = await getCurrentBranch(config.forkPath);
+  if (baseRef !== DEFAULT_BRANCH) {
+    console.info(
+      `${warningMark} ${colors_default.yellow(`not on base branch '${DEFAULT_BRANCH}'`)} ${colors_default.dim(`comparing forks against '${baseRef}'`)}`
+    );
+    console.info(
+      `  ${colors_default.dim(`older merge-base may show extra 'diverged' files; switch to '${DEFAULT_BRANCH}' for the cleanest result`)}`
+    );
+    console.info("");
+  }
+  const validated = forks.map((fork2) => validateForkPath(fork2, config.forkPath));
+  const validForks = validated.filter((v) => v.valid);
+  let selectedFork;
+  if (config.fork) {
+    const match = validated.find((v) => v.fork.name === config.fork);
+    if (!match?.valid) {
+      console.error(colors_default.red(`fork '${config.fork}' not found or invalid in config`));
+      return;
+    }
+    selectedFork = match;
+  } else if (config.list || config.json || config.diff) {
+    if (validForks.length === 0) {
+      console.error(colors_default.red("no valid forks configured"));
+      return;
+    }
+    if (validForks.length > 1) {
+      console.error(colors_default.red("multiple forks configured; pass --fork <name> to choose one"));
+      return;
+    }
+    selectedFork = validForks[0];
+  } else {
+    const choices = validated.map((v) => ({
+      value: v.fork.name,
+      name: v.valid ? `${v.fork.name}  ${colors_default.dim(`[${v.fork.pullBranch}] ${v.fork.localPath}`)}` : `${v.fork.name}  ${colors_default.dim(v.fork.localPath)}`,
+      disabled: v.valid ? false : v.error ?? "invalid"
+    }));
+    const picked = await select2({
+      message: "select fork to pull contributions from:",
+      choices,
+      loop: false
+    });
+    selectedFork = validated.find((v) => v.fork.name === picked);
+  }
+  if (!selectedFork) {
+    console.info(colors_default.dim("no fork selected."));
+    return;
+  }
+  const { fork, resolvedPath } = selectedFork;
+  const forkName = fork.name;
+  createSpinner("pulling fork contributions...");
+  const allItems = [];
+  let forkBanner = null;
+  try {
+    const fetchSource = fork.remoteUrl ?? resolvedPath;
+    const forkRef = await fetchForkBranch(config.forkPath, fetchSource, fork.pullBranch);
+    const meta = await forkRefMeta(config.forkPath, forkRef);
+    forkBanner = { pullBranch: fork.pullBranch, sha: meta.sha, date: meta.date };
+    let forkTerritory = [];
+    try {
+      const forkConfig = await loadConfig(resolvedPath);
+      forkTerritory = forkConfig.overrides?.ignored ?? [];
+    } catch {
+    }
+    const detection = await detectContributableFiles(config.forkPath, baseRef, forkRef, config, forkTerritory);
+    if (countDetection(detection) > 0) {
+      const { branch, appliedFiles } = await buildContribBranch(config.forkPath, baseRef, forkRef, detection, forkName);
+      if (appliedFiles.length > 0) {
+        const stat = await diffStat(config.forkPath, baseRef, branch);
+        const metaByPath = new Map(detection.files.map((f) => [f.path, f]));
+        for (const path4 of [...detection.modified, ...detection.created]) {
+          const fileMeta = metaByPath.get(path4);
+          allItems.push({
+            path: path4,
+            ref: branch,
+            deleted: false,
+            created: fileMeta?.kind === "created",
+            status: fileMeta?.status,
+            changedAt: fileMeta?.changedAt,
+            additions: stat.get(path4)?.additions ?? null,
+            deletions: stat.get(path4)?.deletions ?? null,
+            checked: false
+          });
+        }
+        for (const path4 of detection.deleted) {
+          const fileMeta = metaByPath.get(path4);
+          allItems.push({
+            path: path4,
+            ref: branch,
+            deleted: true,
+            status: fileMeta?.status,
+            changedAt: fileMeta?.changedAt,
+            additions: stat.get(path4)?.additions ?? null,
+            deletions: stat.get(path4)?.deletions ?? null,
+            checked: false
+          });
+        }
+      }
+    }
+  } catch (error) {
+    spinnerFail(`failed to pull ${forkName}`);
+    console.info(colors_default.red(`  \u2717 ${error instanceof Error ? error.message : "unknown error"}`));
+    return;
+  }
+  if (allItems.length === 0) {
+    spinnerSuccess("no contributions found");
+    return;
+  }
+  allItems.sort((a, b) => a.path.localeCompare(b.path));
+  spinnerSuccess(`${allItems.length} files from ${forkName}`);
+  if (!config.list && !config.diff && forkBanner) {
+    console.info(
+      `  ${colors_default.dim(`${forkName}: comparing committed '${forkBanner.pullBranch}' @ ${forkBanner.sha} (${forkBanner.date}) \u2014 uncommitted fork changes are not included`)}`
+    );
+  }
+  if (config.diff) {
+    const matches = allItems.filter((i) => i.path === config.diff);
+    if (matches.length === 0) {
+      console.error(colors_default.red(`no contribution found for path: ${config.diff}`));
+      process.exitCode = 1;
+      return;
+    }
+    for (const item of matches) {
+      const diff = gitDiffFile(config.forkPath, `${baseRef}..${item.ref}`, item.path, { dstPrefix: forkName });
+      writeStdout(diff.toString());
+    }
+    return;
+  }
+  if (config.json) {
+    const out = allItems.map((item) => ({
+      fork: forkName,
+      path: item.path,
+      status: item.status ?? null,
+      kind: item.deleted ? "deleted" : "modified",
+      changedAt: item.changedAt ?? null,
+      additions: item.additions ?? null,
+      deletions: item.deletions ?? null
+    }));
+    writeStdout(JSON.stringify(out, null, 2));
+    return;
+  }
+  if (config.list) {
+    for (const item of allItems) {
+      const status = item.status ?? "behind";
+      const kind = item.deleted ? "deleted" : "modified";
+      const changedAt = item.changedAt ?? "-";
+      console.info(`${forkName}	${status}	${kind}	${changedAt}	${item.path}`);
+    }
+    return;
+  }
+  console.info();
+  console.info(DIVIDER);
+  const selected = await contribPrompt({
+    message: `contributions from ${forkName}`,
+    items: allItems,
+    forkName,
+    baseRef,
+    cwd: config.forkPath,
+    pageSize: 20
+  });
+  if (selected.length === 0) {
+    console.info();
+    return;
+  }
+  createSpinner(`applying ${selected.length} files...`);
+  const applyUnstaged = shouldApplyContributionsUnstaged(config.forkPath);
+  let applied = 0;
+  const errors = [];
+  for (const item of selected) {
+    try {
+      if (item.path.includes("..") || item.path.startsWith("/")) {
+        errors.push(`${item.path}: rejected (path traversal)`);
+        continue;
+      }
+      if (item.deleted) {
+        if (applyUnstaged) {
+          await removeFileFromWorktree(config.forkPath, item.path);
+        } else {
+          await git(["rm", "-f", "--", item.path], config.forkPath, { ignoreErrors: true });
+        }
+      } else {
+        if (applyUnstaged) {
+          await restoreWorktreeFromRef(config.forkPath, item.ref, item.path);
+        } else {
+          await git(["checkout", item.ref, "--", item.path], config.forkPath);
+        }
+      }
+      applied++;
+    } catch (error) {
+      errors.push(`${item.path}: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+  }
+  if (errors.length > 0) {
+    spinnerFail(`applied ${applied}/${selected.length} files (${errors.length} errors)`);
+    for (const err of errors) {
+      console.info(colors_default.red(`  \u2717 ${err}`));
+    }
+  } else {
+    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"
+    )
+  );
+  console.info();
+}
+
+// src/services/forks.ts
+import { resolve as resolve5 } from "path";
+import process7 from "process";
+import { Separator as Separator2, select as select3 } from "@inquirer/prompts";
+
+// src/services/sync.ts
+import { spawnSync as spawnSync4 } from "child_process";
+
+// src/services/packages.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join13 } 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("||")) {
+    return null;
+  }
+  const match = trimmed.match(
+    /^(?:\^|~|>=|<=|>|<|=)?\s*v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/
+  );
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2] ?? 0),
+    patch: Number(match[3] ?? 0)
+  };
+}
+function compareVersions(left, right) {
+  if (left.major !== right.major) return left.major - right.major;
+  if (left.minor !== right.minor) return left.minor - right.minor;
+  return left.patch - right.patch;
+}
+function isHigherVersion(upstreamVersion, forkVersion) {
+  if (upstreamVersion === forkVersion) return false;
+  const upCoerced = parseComparableVersion(upstreamVersion);
+  const forkCoerced = parseComparableVersion(forkVersion);
+  if (!upCoerced || !forkCoerced) return false;
+  return compareVersions(upCoerced, forkCoerced) > 0;
+}
+function safeMergeRecord(forkRecord, upstreamRecord, addOnly = false) {
+  if (!upstreamRecord) return void 0;
+  const merged = { ...forkRecord || {} };
+  const added = [];
+  let changed = false;
+  for (const [name, upstreamValue] of Object.entries(upstreamRecord)) {
+    const forkValue = merged[name];
+    if (forkValue === void 0) {
+      merged[name] = upstreamValue;
+      added.push(name);
+      changed = true;
+    } else if (!addOnly && forkValue !== upstreamValue && isHigherVersion(upstreamValue, forkValue)) {
+      merged[name] = upstreamValue;
+      changed = true;
+    }
+  }
+  const sorted = Object.fromEntries(Object.entries(merged).sort(([a], [b]) => a.localeCompare(b)));
+  return { merged: sorted, changed, added };
+}
+function safeMergePnpm(forkPnpm, upstreamPnpm) {
+  if (!upstreamPnpm) return void 0;
+  const merged = { ...forkPnpm || {} };
+  let changed = false;
+  if (upstreamPnpm.overrides) {
+    const result = safeMergeRecord(
+      merged.overrides,
+      upstreamPnpm.overrides
+    );
+    if (result?.changed) {
+      merged.overrides = result.merged;
+      changed = true;
+    }
+  }
+  if (upstreamPnpm.patchedDependencies) {
+    const forkPatched = merged.patchedDependencies || {};
+    const upstreamPatched = upstreamPnpm.patchedDependencies;
+    for (const [name, value] of Object.entries(upstreamPatched)) {
+      if (!(name in forkPatched)) {
+        forkPatched[name] = value;
+        changed = true;
+      }
+    }
+    if (changed || !merged.patchedDependencies) {
+      merged.patchedDependencies = Object.fromEntries(
+        Object.entries(forkPatched).sort(([a], [b]) => a.localeCompare(b))
+      );
+    }
+  }
+  if (upstreamPnpm.packageExtensions) {
+    const forkExts = merged.packageExtensions || {};
+    const upstreamExts = upstreamPnpm.packageExtensions;
+    for (const [pkg, upstreamExt] of Object.entries(upstreamExts)) {
+      if (!(pkg in forkExts)) {
+        forkExts[pkg] = upstreamExt;
+        changed = true;
+      } else {
+        for (const [subKey, subValue] of Object.entries(upstreamExt)) {
+          if (!(subKey in forkExts[pkg])) {
+            forkExts[pkg][subKey] = subValue;
+            changed = true;
+          }
+        }
+      }
+    }
+    merged.packageExtensions = forkExts;
+  }
+  for (const [key, value] of Object.entries(upstreamPnpm)) {
+    if (["overrides", "patchedDependencies", "packageExtensions"].includes(key)) continue;
+    if (!(key in merged)) {
+      merged[key] = value;
+      changed = true;
+    }
+  }
+  return { merged, changed };
+}
+function readPackageJson(filePath) {
+  if (!existsSync9(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync5(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writePackageJson(filePath, data) {
+  writeFileSync4(filePath, `${JSON.stringify(data, null, 2)}
+`, "utf-8");
+}
+async function getUpstreamPackageJson(forkPath, upstreamRef, relativePath) {
+  const filePath = relativePath ? `${relativePath}/package.json` : "package.json";
+  try {
+    return JSON.parse(await git(["show", `${upstreamRef}:${filePath}`], forkPath));
+  } catch {
+    return null;
+  }
+}
+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")));
+}
+async function syncPackageJson(forkPath, upstreamRef, relativePath, keysToSync) {
+  const changes = [];
+  const pkgPath = join13(forkPath, relativePath, "package.json");
+  const forkPkg = readPackageJson(pkgPath);
+  const upstreamPkg = await getUpstreamPackageJson(forkPath, upstreamRef, relativePath);
+  if (!forkPkg || !upstreamPkg) {
+    return { updated: false, changes };
+  }
+  let updated = false;
+  for (const key of keysToSync) {
+    if (key === "pnpm") {
+      const result2 = safeMergePnpm(forkPkg.pnpm, upstreamPkg.pnpm);
+      if (result2?.changed) {
+        forkPkg.pnpm = result2.merged;
+        updated = true;
+        changes.push("pnpm: merged");
+      }
+      continue;
+    }
+    if (key === "packageManager") {
+      const upstreamValue2 = upstreamPkg[key];
+      const forkValue2 = forkPkg[key];
+      if (upstreamValue2 && !forkValue2) {
+        forkPkg[key] = upstreamValue2;
+        updated = true;
+        changes.push(`${key}: added`);
+      } else if (upstreamValue2 && forkValue2 && upstreamValue2 !== forkValue2 && isHigherVersion(upstreamValue2, forkValue2)) {
+        forkPkg[key] = upstreamValue2;
+        updated = true;
+        changes.push(`${key}: bumped`);
+      }
+      continue;
+    }
+    const forkValue = forkPkg[key];
+    const upstreamValue = upstreamPkg[key];
+    const addOnly = key === "scripts";
+    const result = safeMergeRecord(forkValue, upstreamValue, addOnly);
+    if (result?.changed) {
+      forkPkg[key] = result.merged;
+      updated = true;
+      if (addOnly) {
+        changes.push(...result.added.map((name) => `scripts.${name}: added`));
+      } else {
+        changes.push(`${key}: merged`);
+      }
+    }
+  }
+  if (updated) {
+    writePackageJson(pkgPath, forkPkg);
+  }
+  return { updated, changes };
+}
+async function runPackages(config, options = {}) {
+  createSpinner("syncing package.json files...");
+  const keysToSync = config.settings.packageJsonSync || ["dependencies", "devDependencies"];
+  const conflictedSet = new Set(options.conflictedFiles ?? []);
+  const locations = await discoverPackageLocations(config.forkPath, config.upstreamRef);
+  const results = [];
+  const skipped = [];
+  for (const location of locations) {
+    const pkgRelPath = location ? `${location}/package.json` : "package.json";
+    if (conflictedSet.has(pkgRelPath)) {
+      skipped.push(pkgRelPath);
+      continue;
+    }
+    spinnerText(`syncing ${location || "root"}/package.json...`);
+    const { updated, changes } = 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}`);
+      }
+    }
+  }
+  if (skipped.length > 0) {
+    console.info();
+    console.warn(
+      `${warningMark} skipped ${skipped.length} conflicted package.json file(s) \u2014 resolve the conflicts, commit the merge, then rerun \`pnpm cella sync\`:`
+    );
+    for (const path4 of skipped) {
+      console.warn(`    ${colors_default.dim("\u2192")} ${path4}`);
+    }
+  }
+}
+
+// src/services/sync.ts
+async function ensureBaseUpToDate(forkPath, base) {
+  const { upstream, ahead, behind } = await getUpstreamStatus(forkPath);
+  if (!upstream) {
+    console.info(colors_default.dim(`'${base}' has no upstream \u2014 skipping the up-to-date check.`));
+    return;
+  }
+  if (ahead > 0 && behind > 0) {
+    throw new Error(
+      `'${base}' has diverged from '${upstream}' (${ahead} ahead, ${behind} behind).
+Reconcile '${base}' with '${upstream}' first (e.g. rebase or reset it), then re-run sync.`
+    );
+  }
+  if (behind > 0) {
+    console.info(colors_default.dim(`fast-forwarding '${base}' to '${upstream}' (${behind} behind)...`));
+    await pullFastForward(forkPath);
+    return;
+  }
+  if (ahead > 0) {
+    console.info(colors_default.dim(`'${base}' is ${ahead} commit(s) ahead of '${upstream}' (unpushed) \u2014 continuing.`));
+  }
+}
+async function setupTemporarySyncBranch(config) {
+  const { forkPath, settings } = config;
+  const base = resolveReleaseBase(settings);
+  const startBranch = await getCurrentBranch(forkPath);
+  console.info(colors_default.dim(`switching to '${base}' and updating...`));
+  await switchBranch(forkPath, base);
+  await ensureBaseUpToDate(forkPath, base);
+  const temporaryBranch = buildTemporarySyncBranch();
+  console.info(colors_default.dim(`creating temporary sync branch '${temporaryBranch}' from '${base}'...`));
+  console.info();
+  await createBranchFrom(forkPath, temporaryBranch, base);
+  return { temporaryBranch, base, startBranch };
+}
+async function runSync(config, options) {
+  createSpinner("starting sync...");
+  const result = await runMergeEngine(config, {
+    apply: true,
+    onProgress: (message) => {
+      spinnerText(message);
+    },
+    onStep: (label, detail) => {
+      spinnerSuccess(label, detail);
+      createSpinner("...");
+    }
+  });
+  if (result.success) {
+    spinnerSuccess();
+  } else {
+    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);
+  printFlagWarnings({ hard: config.hard, unpinned: config.unpinned });
+  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`));
+}
+function printShipSteps(temporaryBranch, base) {
+  console.info(colors_default.dim(`  git push -u origin ${temporaryBranch}`));
+  printPrCreateStep(temporaryBranch, base);
+}
+function printFinishSteps() {
+  console.info(colors_default.dim("  pnpm cella sync"));
+}
+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;
+}
+async function shipSyncBranch(config, branch) {
+  const { forkPath, settings } = config;
+  const base = resolveReleaseBase(settings);
+  console.info(colors_default.dim(`pushing '${branch}' to origin...`));
+  try {
+    await pushBranch(forkPath, "origin", branch);
+  } 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);
+    return;
+  }
+  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"], {
+      cwd: forkPath,
+      stdio: "inherit"
+    });
+    if (pr.status !== 0) {
+      console.info(colors_default.yellow("could not open the PR automatically (it may already exist). open it with:"));
+      printPrCreateStep(branch, base);
+    }
+  } else {
+    console.info(colors_default.yellow("`gh` not found \u2014 open the PR manually:"));
+    printPrCreateStep(branch, base);
+  }
+  console.info(colors_default.dim(`switching back to '${base}'...`));
+  await switchBranch(forkPath, base);
+  await pullFastForward(forkPath).catch(() => {
+  });
+  console.info(colors_default.green(`done \u2014 '${branch}' is pushed and you're 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" });
+    if (result.status !== 0) return false;
+  }
+  return true;
+}
+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);
+      }
+    }
+  });
+  if (config.settings.syncWithPackages !== false) {
+    await runPackages(config, { conflictedFiles: result.conflicts });
+  }
+  if (result.conflicts.length > 0) return { status: "conflicts", branch };
+  if (!mergeInProgress(forkPath)) {
+    await switchBranch(forkPath, branch.startBranch === branch.temporaryBranch ? branch.base : branch.startBranch);
+    await deleteBranch(forkPath, branch.temporaryBranch);
+    return { status: "noop" };
+  }
+  return { status: "staged", branch };
+}
+async function resumeSyncMerge(config, branch) {
+  const { forkPath } = config;
+  const conflicts = await getConflictedFiles(forkPath);
+  console.info();
+  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."));
+    return;
+  }
+  await stageAll(forkPath);
+  if (!finalizeWorkspace(forkPath)) {
+    console.info();
+    console.info(
+      colors_default.yellow("`pnpm install`/`pnpm check` failed. fix the issues, then re-run `pnpm cella sync` to finish.")
+    );
+    return;
+  }
+  const upstreamSha = await getShortSha(forkPath, "MERGE_HEAD").catch(() => "");
+  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}'.`));
+  await shipSyncBranch(config, branch);
+}
+async function runSyncCommand(config) {
+  const { forkPath } = config;
+  const currentBranch = await getCurrentBranch(forkPath);
+  const onSyncBranch = isTemporarySyncBranch(currentBranch);
+  if (onSyncBranch && mergeInProgress(forkPath)) {
+    await resumeSyncMerge(config, currentBranch);
+    return;
+  }
+  if (onSyncBranch) {
+    if (!await isClean(forkPath)) {
+      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\`.`
+        )
+      );
+      return;
+    }
+    console.info();
+    console.info(colors_default.green(`sync branch '${currentBranch}' is already committed.`));
+    await shipSyncBranch(config, currentBranch);
+    return;
+  }
+  await assertClean(forkPath);
+  const outcome = await runSyncCycle(config);
+  console.info();
+  if (outcome.status === "noop") {
+    console.info(colors_default.green("already up to date with upstream \u2014 nothing to sync."));
+    return;
+  }
+  const { temporaryBranch } = outcome.branch;
+  if (outcome.status === "conflicts") {
+    console.info(`${warningMark} ${colors_default.yellow(`conflicts on '${temporaryBranch}'. Resolve them and then:`)}`);
+    printFinishSteps();
+  }
+}
+
+// src/services/forks.ts
+async function gatherForkStatus(forkPath) {
+  const [branch, porcelain, syncRef] = await Promise.all([
+    getCurrentBranch(forkPath).catch(() => "unknown"),
+    git(["status", "--porcelain"], forkPath, { ignoreErrors: true }),
+    getStoredSyncRef(forkPath)
+  ]);
+  const dirty = porcelain ? porcelain.split("\n").filter(Boolean).length : 0;
+  let lastSync = null;
+  if (syncRef) {
+    const commitInfo = await getCommitInfo(forkPath, syncRef).catch(() => null);
+    lastSync = { date: commitInfo?.date ?? "unknown", message: commitInfo?.message ?? "" };
+  }
+  return { branch, dirty, lastSync };
+}
+function formatForkChoice(name, status) {
+  if (!status) return name;
+  let syncPart;
+  if (status.lastSync) {
+    const msg = status.lastSync.message.length > 36 ? `${status.lastSync.message.slice(0, 36)}\u2026` : status.lastSync.message;
+    syncPart = colors_default.dim(`${status.lastSync.date}`);
+    if (msg) syncPart += colors_default.dim(` '${msg}'`);
+  } else {
+    syncPart = colors_default.dim("never synced");
+  }
+  const dirtyPart = status.dirty > 0 ? colors_default.yellow(`${status.dirty} uncommitted`) : "";
+  const parts = [name, colors_default.dim(`[${status.branch}]`), syncPart];
+  if (dirtyPart) parts.push(dirtyPart);
+  return parts.join(colors_default.dim(" \xB7 "));
+}
+async function buildForkChoices(forks, basePath) {
+  const validated = forks.map((fork) => validateForkPath(fork, basePath, true));
+  const statusEntries = await Promise.all(
+    validated.filter((v) => v.valid).map(async (v) => {
+      const status = await gatherForkStatus(v.resolvedPath);
+      return { path: v.fork.localPath, status };
+    })
+  );
+  const statusMap = new Map(statusEntries.map((e) => [e.path, e.status]));
+  return validated.map((v) => {
+    if (!v.valid) {
+      return {
+        value: v.fork.localPath,
+        name: `${v.fork.name}  ${colors_default.dim(v.fork.localPath)}`,
+        disabled: v.error
+      };
+    }
+    return {
+      value: v.fork.localPath,
+      name: formatForkChoice(v.fork.name, statusMap.get(v.fork.localPath) ?? null)
+    };
+  });
+}
+async function syncFork(config, fork, forkPath) {
+  console.info();
+  console.info(colors_default.cyan(`syncing to ${fork.name}...`));
+  console.info(colors_default.dim(`path: ${forkPath}`));
+  console.info();
+  const forkConfig = await loadConfig(forkPath);
+  const { branchRef } = resolveUpstream(forkConfig.settings);
+  const upstreamRef = branchRef;
+  const forkRuntimeConfig = {
+    ...forkConfig,
+    forkPath,
+    upstreamRef,
+    service: "sync",
+    logFile: config.logFile,
+    list: false,
+    json: false,
+    verbose: config.verbose,
+    hard: config.hard
+  };
+  await runSyncCommand(forkRuntimeConfig);
+}
+async function runForks(config) {
+  const forks = config.forks ?? [];
+  if (forks.length === 0) {
+    printNoForksHint("add forks to your config:");
+    return;
+  }
+  if (config.fork) {
+    const match = forks.find((f) => f.name === config.fork);
+    if (!match) {
+      console.error(colors_default.red(`fork '${config.fork}' not found in config`));
+      return;
+    }
+    const resolvedPath = resolve5(config.forkPath, match.localPath);
+    await syncFork(config, match, resolvedPath);
+    return;
+  }
+  while (true) {
+    const choices = await buildForkChoices(forks, config.forkPath);
+    const forkChoices = [...choices, new Separator2("\u2500".repeat(40)), { value: "_exit", name: colors_default.dim("exit") }];
+    const selectedPath = await select3({
+      message: "select fork to sync:",
+      choices: forkChoices,
+      loop: false
+    });
+    if (selectedPath === "_exit") {
+      process7.exit(0);
+    }
+    const resolvedForkPath = resolve5(config.forkPath, selectedPath);
+    const selectedFork = forks.find((f) => f.localPath === selectedPath);
+    if (!selectedFork) {
+      console.error(colors_default.red(`fork '${selectedPath}' not found in config`));
+      continue;
+    }
+    await syncFork(config, selectedFork, resolvedForkPath);
+    console.info();
+  }
+}
+
+// src/services/stats.ts
+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 * as fs3 from "fs";
+import * as path3 from "path";
+var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
+function summaryPath(forkPath) {
+  return path3.join(forkPath, ".coverage", "coverage-summary.json");
+}
+function colorPct(pct) {
+  const label = `${pct.toFixed(2)}%`;
+  if (pct >= 80) return colors_default.green(label);
+  if (pct >= 50) return colors_default.yellow(label);
+  return colors_default.red(label);
+}
+function formatAge(ms) {
+  const days = Math.floor(ms / (24 * 60 * 60 * 1e3));
+  if (days >= 1) return `${days} day${days === 1 ? "" : "s"} ago`;
+  const hours = Math.floor(ms / (60 * 60 * 1e3));
+  if (hours >= 1) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const mins = Math.floor(ms / (60 * 1e3));
+  return `${mins} minute${mins === 1 ? "" : "s"} ago`;
+}
+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" });
+  return result.status === 0;
+}
+function printCoverageSummary(forkPath, options = {}) {
+  const file = summaryPath(forkPath);
+  if (options.refresh) {
+    const ok = refreshCoverage(forkPath);
+    if (!ok) {
+      console.info(colors_default.red("coverage run failed \u2014 showing last cached results (if any)"));
+    }
+    console.info();
+  }
+  if (!fs3.existsSync(file)) {
+    console.info(colors_default.bold("coverage"));
+    console.info(colors_default.yellow("  no coverage data found \u2014 run `pnpm test` to generate it"));
+    console.info();
+    return;
+  }
+  let summary;
+  let mtimeMs;
+  try {
+    summary = JSON.parse(fs3.readFileSync(file, "utf-8"));
+    mtimeMs = fs3.statSync(file).mtimeMs;
+  } catch {
+    console.info(colors_default.bold("coverage"));
+    console.info(colors_default.yellow("  could not read coverage-summary.json \u2014 run `pnpm test` to regenerate"));
+    console.info();
+    return;
+  }
+  const ageMs = Date.now() - mtimeMs;
+  const stale = ageMs > STALE_THRESHOLD_MS;
+  const perPackage = /* @__PURE__ */ new Map();
+  for (const [key, entry] of Object.entries(summary)) {
+    if (key === "total") continue;
+    const rel = path3.relative(forkPath, key);
+    if (rel.startsWith("..")) continue;
+    const pkg = rel.split(path3.sep)[0];
+    const acc = perPackage.get(pkg) ?? { covered: 0, total: 0 };
+    acc.covered += entry.lines.covered;
+    acc.total += entry.lines.total;
+    perPackage.set(pkg, acc);
+  }
+  const ageLabel = formatAge(ageMs);
+  console.info(colors_default.bold("coverage"), colors_default.dim(`(updated ${ageLabel})`));
+  if (stale) {
+    console.info(colors_default.yellow("  \u26A0 data is older than 7 days \u2014 run `pnpm test` to refresh"));
+  }
+  const total = summary.total;
+  console.info(
+    `  ${colors_default.bold("overall")}  lines ${colorPct(total.lines.pct)} ${colors_default.dim(`(${total.lines.covered}/${total.lines.total})`)}  funcs ${colorPct(total.functions.pct)}  branches ${colorPct(total.branches.pct)}`
+  );
+  const rows = [...perPackage.entries()].map(([pkg, v]) => ({ pkg, pct: v.total ? 100 * v.covered / v.total : 0, ...v })).sort((a, b) => a.pct - b.pct);
+  const nameWidth = Math.max(...rows.map((r) => r.pkg.length), 0);
+  for (const r of rows) {
+    console.info(`    ${r.pkg.padEnd(nameWidth)}  ${colorPct(r.pct)} ${colors_default.dim(`(${r.covered}/${r.total})`)}`);
+  }
+  console.info();
+}
+
+// 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");
+  return parseYamlBlockList(content, "packages").map((pattern) => {
+    if (pattern.endsWith("/*")) {
+      const base = pattern.slice(0, -2);
+      return { name: `${base}/*`, prefix: `${base}/` };
+    }
+    return { name: pattern, prefix: `${pattern}/` };
+  });
+}
+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(".gen.") || filePath.includes(".gen/") || filePath.includes("/gen/") || filePath.startsWith("drizzle/") || filePath.includes("/drizzle/") || filePath.endsWith(".d.ts") || filePath.includes(".tsbuildinfo")) {
+    return "generated";
+  }
+  if (filePath.endsWith(".json") || filePath.endsWith(".jsonc")) {
+    return "json";
+  }
+  return "other";
+}
+function matchPackage(filePath, packages) {
+  for (const pkg of packages) {
+    if (pkg.name.endsWith("/*")) {
+      if (filePath.startsWith(pkg.prefix)) {
+        const rest = filePath.slice(pkg.prefix.length);
+        const subDir = rest.split("/")[0];
+        if (subDir) {
+          return `${pkg.prefix}${subDir}`;
+        }
+      }
+    } else if (filePath.startsWith(pkg.prefix)) {
+      return pkg.name;
+    }
+  }
+  return "(root)";
+}
+var sourcePathspecs = [...sourceExtensions].map((ext) => `*.${ext}`);
+async function collectStats(forkPath) {
+  const output = await git(["grep", "-c", "", "--", ...sourcePathspecs], forkPath, { ignoreErrors: true });
+  const allFilesOutput = await git(["ls-files", "--cached"], forkPath);
+  const allFilesCount = allFilesOutput.split("\n").filter(Boolean).length;
+  const packages = await getWorkspacePackages(forkPath);
+  const entries = [];
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const sep3 = line.lastIndexOf(":");
+    if (sep3 === -1) continue;
+    entries.push({ path: line.slice(0, sep3), loc: Number.parseInt(line.slice(sep3 + 1), 10) });
+  }
+  const skipped = allFilesCount - entries.length;
+  const emptyCat = () => ({
+    test: { files: 0, loc: 0 },
+    generated: { files: 0, loc: 0 },
+    json: { files: 0, loc: 0 },
+    other: { files: 0, loc: 0 }
+  });
+  const categories = emptyCat();
+  const pkgStats = /* @__PURE__ */ new Map();
+  let totalLoc = 0;
+  for (const { path: path4, loc } of entries) {
+    const category = classifyFile(path4);
+    categories[category].files++;
+    categories[category].loc += loc;
+    totalLoc += loc;
+    const pkg = matchPackage(path4, packages);
+    let entry = pkgStats.get(pkg);
+    if (!entry) {
+      entry = { total: 0, loc: 0, categories: emptyCat() };
+      pkgStats.set(pkg, entry);
+    }
+    entry.total++;
+    entry.loc += loc;
+    entry.categories[category].files++;
+    entry.categories[category].loc += loc;
+  }
+  const sortedPackages = Object.fromEntries(
+    [...pkgStats.entries()].sort((a, b) => b[1].categories.other.loc - a[1].categories.other.loc)
+  );
+  return { total: entries.length, totalLoc, skipped, categories, packages: sortedPackages };
+}
+function pad(n, width = 6) {
+  return String(n).padStart(width);
+}
+function formatLoc(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function formatLocColumn(n, width = 8) {
+  return formatLoc(n).padStart(width);
+}
+function fmtPct(value, total) {
+  const pct = (value / total * 100).toFixed(1);
+  return `${pct.padStart(5)}%`;
+}
+function printStats(stats, verbose) {
+  console.info();
+  console.info(
+    `  ${colors_default.bold("source files")}  ${String(stats.total)}  ${colors_default.dim(`(${stats.skipped} non-source skipped)`)}`
+  );
+  console.info(`  ${colors_default.bold("lines of code")} ${colors_default.cyan(formatLoc(stats.totalLoc))}`);
+  console.info();
+  const catEntries = [
+    ["source & config", stats.categories.other],
+    ["test", stats.categories.test],
+    ["generated", stats.categories.generated],
+    ["json", stats.categories.json]
+  ];
+  for (const [label, data] of catEntries) {
+    console.info(
+      `  ${pad(data.files)} ${colors_default.dim(fmtPct(data.files, stats.total))}  ${label.padEnd(18)} ${colors_default.cyan(formatLocColumn(data.loc))}  ${colors_default.dim(fmtPct(data.loc, stats.totalLoc))}`
+    );
+  }
+  console.info();
+  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)}`;
+    console.info(colors_default.dim(header));
+    for (const [name, data] of Object.entries(stats.packages)) {
+      const c = data.categories;
+      const srcFiles = c.other.files;
+      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))}`
+      );
+    }
+  } else {
+    for (const [name, data] of Object.entries(stats.packages)) {
+      const srcFiles = data.categories.other.files;
+      const srcLoc = data.categories.other.loc;
+      if (srcFiles === 0) continue;
+      console.info(
+        `  ${pad(srcFiles)} ${colors_default.dim(fmtPct(srcFiles, stats.categories.other.files))}  ${name.padEnd(18)} ${colors_default.cyan(formatLocColumn(srcLoc))}  ${colors_default.dim(fmtPct(srcLoc, stats.categories.other.loc))}`
+      );
+    }
+  }
+  console.info();
+}
+async function runStats(forkPath, options = {}) {
+  createSpinner("counting files...");
+  const stats = await collectStats(forkPath);
+  spinnerSuccess("Finished counting by raw line of code");
+  if (options.json) {
+    console.info(JSON.stringify(stats, null, 2));
+  } else {
+    printStats(stats, options.verbose ?? false);
+    console.info();
+    printCoverageSummary(forkPath, { refresh: options.refreshCoverage });
+  }
+}
+
+// src/cella-cli.ts
+function getForkPath() {
+  const envPath = process8.env.CELLA_FORK_PATH;
+  if (envPath) {
+    const resolved = resolve6(envPath);
+    if (!existsSync11(resolved) || !statSync2(resolved).isDirectory()) {
+      throw new Error(`CELLA_FORK_PATH is not a valid directory: ${resolved}`);
+    }
+    return resolved;
+  }
+  let cwd = process8.cwd();
+  if (cwd.endsWith("/cli/cella") || cwd.endsWith("\\cli\\cella")) {
+    cwd = resolve6(cwd, "../..");
+  }
+  return cwd;
+}
+async function preflight(forkPath) {
+  if (!existsSync11(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";
+}
+async function main() {
+  registerSignalHandlers();
+  try {
+    const forkPath = getForkPath();
+    if (isHelpOrVersionRequest()) {
+      await parseCli({ settings: { upstreamUrl: "", upstreamBranch: "main" } }, forkPath);
+      return;
+    }
+    const userConfig = await loadConfig(forkPath);
+    const config = await parseCli(userConfig, forkPath);
+    if (!["audit", "forks", "contributions", "stats"].includes(config.service)) {
+      await preflight(forkPath);
+    }
+    switch (config.service) {
+      case "analyze": {
+        await runAnalyze(config);
+        break;
+      }
+      case "sync": {
+        await runSyncCommand(config);
+        break;
+      }
+      case "audit":
+        await runAudit(config, { force: config.force, checkOverrides: config.checkOverrides });
+        break;
+      case "forks":
+        await runForks(config);
+        break;
+      case "contributions":
+        await runContributions(config);
+        break;
+      case "stats":
+        await runStats(config.forkPath, { verbose: config.verbose, refreshCoverage: config.coverage });
+        break;
+    }
+    console.info();
+  } catch (error) {
+    console.error();
+    console.error(`${colors_default.red("\u2717")} ${error instanceof Error ? error.message : "unknown error"}`);
+    process8.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map