create-projx 1.5.4 → 1.5.6

package/dist/chunk-G74HYIE4.js

@@ -0,0 +1,629 @@
+import {
+  DEFAULT_COMPONENT_SKIP_PATTERNS,
+  DEFAULT_ROOT_SKIP_PATTERNS,
+  copyComponent,
+  copyStaticFiles,
+  readComponentMarker,
+  readProjxConfig,
+  render,
+  replaceInDir,
+  replaceInFile,
+  sharedTemplateDir,
+  toSnake,
+  upsertComponentMarker,
+  writeProjxConfig
+} from "./chunk-FTHX7ILT.js";
+
+// src/baseline.ts
+import { existsSync, writeFileSync, unlinkSync } from "fs";
+import { chmod, mkdir, writeFile, rm, readFile as readFile2 } from "fs/promises";
+import { execSync } from "child_process";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+
+// src/generators/index.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function renderShared(filename, vars) {
+  const tpl = await readFile(
+    join(sharedTemplateDir(), filename),
+    "utf-8"
+  );
+  return render(tpl, vars);
+}
+async function generateDockerCompose(vars) {
+  return renderShared("docker-compose.yml.ejs", vars);
+}
+async function generateDockerComposeDev(vars) {
+  return renderShared("docker-compose.dev.yml.ejs", vars);
+}
+async function generatePreCommit(vars) {
+  return renderShared("pre-commit.ejs", vars);
+}
+async function generateSetupSh(vars) {
+  return renderShared("setup.sh.ejs", vars);
+}
+async function generateCiYml(vars) {
+  return renderShared("ci.yml.ejs", vars);
+}
+async function generateReadme(vars) {
+  return renderShared("README.md.ejs", vars);
+}
+function generateVscodeSettings(vars) {
+  const settings = {};
+  if (vars.components.includes("fastapi")) {
+    settings["[python]"] = {
+      "editor.defaultFormatter": "charliermarsh.ruff",
+      "editor.codeActionsOnSave": { "source.fixAll.ruff": "explicit" }
+    };
+  }
+  settings["[typescript]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
+  settings["[typescriptreact]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
+  settings["[javascript]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
+  settings["[json]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
+  settings["[css]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
+  settings["[yaml]"] = { "editor.defaultFormatter": "esbenp.prettier-vscode" };
+  settings["editor.formatOnSave"] = true;
+  settings["editor.codeActionsOnSave"] = { "source.fixAll.eslint": "explicit" };
+  settings["eslint.useFlatConfig"] = true;
+  const prettierComponent = ["frontend", "fastify", "e2e"].find(
+    (c) => vars.components.includes(c)
+  );
+  if (prettierComponent) {
+    settings["prettier.configPath"] = `${vars.paths[prettierComponent]}/.prettierrc`;
+  }
+  if (vars.components.includes("fastapi")) {
+    settings["ruff.lineLength"] = 120;
+    settings["python.analysis.extraPaths"] = [`${vars.paths.fastapi}/src`];
+    settings["python.analysis.importFormat"] = "absolute";
+  }
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+
+// src/baseline.ts
+function buildPathsUpper(paths) {
+  const result = {};
+  for (const [component, dir] of Object.entries(paths)) {
+    result[component] = dir.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase();
+  }
+  return result;
+}
+var CANONICAL_DISPLAY_NAMES = {
+  fastapi: "FastAPI",
+  fastify: "Fastify",
+  frontend: "Frontend",
+  mobile: "Flutter",
+  e2e: "E2E",
+  infra: "Terraform"
+};
+function buildDisplayNames(paths) {
+  const result = {};
+  for (const [component, dir] of Object.entries(paths)) {
+    const canonical = component;
+    result[canonical] = dir === canonical ? CANONICAL_DISPLAY_NAMES[canonical] : dir;
+  }
+  return result;
+}
+var BASELINE_REF = "refs/projx/baseline";
+async function migrateComponentMarkers(cwd, components, componentPaths, applyDefaults) {
+  const { readComponentMarker: readComponentMarker2, writeComponentMarker } = await import("./utils-OOY5OZDX.js");
+  for (const component of components) {
+    const dir = componentPaths[component];
+    const markerDir = join2(cwd, dir);
+    if (!existsSync(markerDir)) continue;
+    const marker = await readComponentMarker2(markerDir);
+    if (!marker) continue;
+    const next = { ...marker };
+    if (applyDefaults) {
+      const defaults = DEFAULT_COMPONENT_SKIP_PATTERNS[component] ?? [];
+      next.skip = [.../* @__PURE__ */ new Set([...marker.skip, ...defaults])];
+    }
+    await writeComponentMarker(markerDir, next);
+  }
+}
+async function writeManagedProjx(cwd, version, vars, applyDefaults) {
+  const existing = await readProjxConfig(cwd);
+  delete existing.components;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const merged = {
+    ...existing,
+    version,
+    updatedAt: today
+  };
+  const pmObj = vars.pm;
+  if (pmObj?.name && !merged.packageManager) {
+    merged.packageManager = pmObj.name;
+  }
+  if (applyDefaults && !merged.defaultsApplied) {
+    const userSkip = Array.isArray(merged.skip) ? merged.skip : [];
+    merged.skip = [.../* @__PURE__ */ new Set([...userSkip, ...DEFAULT_ROOT_SKIP_PATTERNS])];
+    merged.defaultsApplied = true;
+  }
+  await writeProjxConfig(cwd, merged);
+}
+function matchesSkip(filePath, patterns) {
+  for (const pattern of patterns) {
+    if (pattern === "**") return true;
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3);
+      if (filePath.startsWith(prefix + "/") || filePath === prefix) return true;
+    }
+    if (pattern.startsWith("**/")) {
+      const suffix = pattern.slice(3);
+      if (suffix.startsWith("*.")) {
+        const ext = suffix.slice(1);
+        if (filePath.endsWith(ext)) return true;
+      } else if (filePath.endsWith(suffix) || filePath.includes("/" + suffix)) {
+        return true;
+      }
+    }
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      if (filePath.endsWith(ext)) return true;
+    }
+    if (filePath === pattern) return true;
+  }
+  return false;
+}
+function saveBaselineRef(cwd) {
+  try {
+    const head = execSync("git rev-parse HEAD", { cwd, stdio: "pipe" }).toString().trim();
+    execSync(`git update-ref ${BASELINE_REF} ${head}`, { cwd, stdio: "pipe" });
+  } catch {
+  }
+}
+function getBaselineRef(cwd) {
+  try {
+    return execSync(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" }).toString().trim();
+  } catch {
+  }
+  try {
+    const sha = execSync("git log -1 --format=%H -- .projx", { cwd, stdio: "pipe" }).toString().trim();
+    if (sha) return sha;
+  } catch {
+  }
+  return null;
+}
+function getFileAtRef(cwd, ref, filePath) {
+  try {
+    return execSync(`git show ${ref}:"${filePath}"`, { cwd, stdio: "pipe" }).toString();
+  } catch {
+    return null;
+  }
+}
+function mergeFileThreeWay(oursPath, baseContent, theirsContent) {
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const baseTmp = join2(tmpdir(), `projx-base-${id}`);
+  const theirsTmp = join2(tmpdir(), `projx-theirs-${id}`);
+  try {
+    writeFileSync(baseTmp, baseContent);
+    writeFileSync(theirsTmp, theirsContent);
+    execSync(
+      `git merge-file -L "your changes" -L "previous projx baseline" -L "new projx template" "${oursPath}" "${baseTmp}" "${theirsTmp}"`,
+      { stdio: "pipe" }
+    );
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      unlinkSync(baseTmp);
+    } catch {
+    }
+    try {
+      unlinkSync(theirsTmp);
+    } catch {
+    }
+  }
+}
+async function collectAllFiles(dir, base) {
+  const { readdir } = await import("fs/promises");
+  const results = [];
+  const walk = async (current) => {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else {
+        results.push(full.slice(base.length + 1));
+      }
+    }
+  };
+  await walk(dir);
+  return results;
+}
+function buildPathFallbacks(componentPaths) {
+  const fallbacks = {};
+  for (const [component, dir] of Object.entries(componentPaths)) {
+    if (dir !== component) fallbacks[dir] = component;
+  }
+  return fallbacks;
+}
+function lookupBaseContent(cwd, baselineRef, file, pathFallbacks) {
+  const direct = getFileAtRef(cwd, baselineRef, file);
+  if (direct !== null) return direct;
+  const slash = file.indexOf("/");
+  if (slash === -1) return null;
+  const topDir = file.slice(0, slash);
+  const canonical = pathFallbacks[topDir];
+  if (!canonical) return null;
+  return getFileAtRef(cwd, baselineRef, canonical + file.slice(slash));
+}
+async function tryThreeWayMerge(cwd, templateDir, baselineRef, componentPaths) {
+  const templateFiles = await collectAllFiles(templateDir, templateDir);
+  const merged = [];
+  const conflicted = [];
+  const pathFallbacks = buildPathFallbacks(componentPaths);
+  for (const file of templateFiles) {
+    if (file === ".projx") continue;
+    if (file.endsWith("/.projx-component") || file === ".projx-component") continue;
+    const oursPath = join2(cwd, file);
+    if (!existsSync(oursPath)) continue;
+    const baseContent = lookupBaseContent(cwd, baselineRef, file, pathFallbacks);
+    if (baseContent === null) continue;
+    let theirsContent;
+    try {
+      theirsContent = await readFile2(join2(templateDir, file), "utf-8");
+    } catch {
+      continue;
+    }
+    const oursContent = await readFile2(oursPath, "utf-8");
+    if (theirsContent === baseContent) continue;
+    if (oursContent === baseContent) {
+      await writeFile(oursPath, theirsContent);
+      merged.push(file);
+      continue;
+    }
+    if (oursContent === theirsContent) continue;
+    const clean = mergeFileThreeWay(oursPath, baseContent, theirsContent);
+    if (clean) {
+      merged.push(file);
+    } else {
+      conflicted.push(file);
+    }
+  }
+  return { merged, conflicted };
+}
+function createOrphanWorktree(cwd) {
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const branch = `projx/tmp-${id}`;
+  const worktree = join2(tmpdir(), `projx-wt-${id}`);
+  try {
+    execSync("git worktree prune", { cwd, stdio: "pipe" });
+  } catch {
+  }
+  execSync(`git worktree add --orphan -b ${branch} "${worktree}"`, {
+    cwd,
+    stdio: "pipe"
+  });
+  return { worktree, branch };
+}
+function cleanupWorktree(cwd, worktree, branch) {
+  try {
+    execSync(`git worktree remove "${worktree}" --force`, { cwd, stdio: "pipe" });
+  } catch {
+    try {
+      rm(worktree, { recursive: true, force: true });
+      execSync("git worktree prune", { cwd, stdio: "pipe" });
+    } catch {
+    }
+  }
+  try {
+    execSync(`git branch -D ${branch}`, { cwd, stdio: "pipe" });
+  } catch {
+  }
+}
+async function removeSkippedFiles(dir, skipPatterns, realDir) {
+  if (skipPatterns.length === 0) return;
+  const { readdir, unlink } = await import("fs/promises");
+  const walk = async (current, base) => {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join2(current, entry.name);
+      const rel = full.slice(base.length + 1);
+      if (entry.isDirectory()) {
+        await walk(full, base);
+      } else if (entry.name !== ".projx-component" && matchesSkip(rel, skipPatterns)) {
+        if (realDir && !existsSync(join2(realDir, rel))) continue;
+        await unlink(full);
+      }
+    }
+  };
+  await walk(dir, dir);
+}
+async function writeTemplateToDir(dest, repoDir, components, componentPaths, vars, version, options = {}) {
+  const { componentSkips, rootSkip, applyDefaults = false, realCwd = dest } = options;
+  const name = vars.projectName;
+  const nameSnake = toSnake(name);
+  for (const component of components) {
+    const targetDir = componentPaths[component];
+    const baseSkip = componentSkips?.[component] ?? [];
+    const realMarker = await readComponentMarker(join2(realCwd, targetDir));
+    const isNewMarker = !realMarker;
+    const shouldApplyComponentDefault = isNewMarker || applyDefaults;
+    const defaultSkip = shouldApplyComponentDefault ? DEFAULT_COMPONENT_SKIP_PATTERNS[component] ?? [] : [];
+    const skipPatterns = [.../* @__PURE__ */ new Set([...baseSkip, ...defaultSkip])];
+    const tmpDir = join2(dest, "__cptmp__");
+    await copyComponent(repoDir, component, tmpDir);
+    const srcDir = join2(tmpDir, component);
+    if (skipPatterns.length > 0) {
+      const realComponentDir = join2(realCwd, targetDir);
+      await removeSkippedFiles(srcDir, skipPatterns, realComponentDir);
+    }
+    const outDir = join2(dest, targetDir);
+    await mkdir(outDir, { recursive: true });
+    const { cp } = await import("fs/promises");
+    if (existsSync(srcDir)) {
+      await cp(srcDir, outDir, { recursive: true, force: true });
+    }
+    await rm(tmpDir, { recursive: true, force: true });
+    await upsertComponentMarker(join2(dest, targetDir), component, skipPatterns.length > 0 ? skipPatterns : void 0);
+  }
+  if (!vars.pathsUpper) {
+    vars.pathsUpper = buildPathsUpper(componentPaths);
+  }
+  if (!vars.displayNames) {
+    vars.displayNames = buildDisplayNames(componentPaths);
+  }
+  await substituteNames(dest, components, componentPaths, name, nameSnake, vars.nameOverrides);
+  const hasBackend = components.includes("fastapi") || components.includes("fastify");
+  const userSkip = rootSkip ?? [];
+  const defaultRootSkip = applyDefaults ? DEFAULT_ROOT_SKIP_PATTERNS : [];
+  const effectiveSkip = [.../* @__PURE__ */ new Set([...userSkip, ...defaultRootSkip])];
+  const shouldWrite = (file) => {
+    if (!matchesSkip(file, effectiveSkip)) return true;
+    return !existsSync(join2(realCwd, file));
+  };
+  if (hasBackend || components.includes("frontend")) {
+    if (shouldWrite("docker-compose.yml"))
+      await writeFile(join2(dest, "docker-compose.yml"), await generateDockerCompose(vars));
+    if (shouldWrite("docker-compose.dev.yml"))
+      await writeFile(join2(dest, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
+  }
+  if (shouldWrite("README.md"))
+    await writeFile(join2(dest, "README.md"), await generateReadme(vars));
+  if (shouldWrite(".githooks/pre-commit")) {
+    await mkdir(join2(dest, ".githooks"), { recursive: true });
+    await writeFile(join2(dest, ".githooks/pre-commit"), await generatePreCommit(vars));
+    await chmod(join2(dest, ".githooks/pre-commit"), 493);
+  }
+  if (shouldWrite(".github/workflows/ci.yml")) {
+    await mkdir(join2(dest, ".github/workflows"), { recursive: true });
+    await writeFile(join2(dest, ".github/workflows/ci.yml"), await generateCiYml(vars));
+  }
+  if (shouldWrite("setup.sh")) {
+    await writeFile(join2(dest, "setup.sh"), await generateSetupSh(vars));
+    await chmod(join2(dest, "setup.sh"), 493);
+  }
+  await copyStaticFiles(repoDir, dest);
+  if (shouldWrite(".vscode/settings.json")) {
+    await mkdir(join2(dest, ".vscode"), { recursive: true });
+    await writeFile(join2(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
+  }
+  await writeManagedProjx(dest, version, vars, applyDefaults);
+}
+async function substituteNames(dest, components, paths, name, nameSnake, overrides) {
+  if (components.includes("fastapi")) {
+    const target = overrides?.fastapi ?? `${name}-fastapi`;
+    await replaceInFile(join2(dest, `${paths.fastapi}/pyproject.toml`), "projx-fastapi", target);
+  }
+  if (components.includes("fastify")) {
+    const target = overrides?.fastify ?? `${name}-fastify`;
+    await replaceInFile(join2(dest, `${paths.fastify}/package.json`), "projx-fastify", target);
+  }
+  if (components.includes("frontend")) {
+    const target = overrides?.frontend ?? `${name}-frontend`;
+    await replaceInFile(join2(dest, `${paths.frontend}/package.json`), "projx-frontend", target);
+  }
+  if (components.includes("e2e")) {
+    const target = overrides?.e2e ?? `${name}-e2e`;
+    await replaceInFile(join2(dest, `${paths.e2e}/package.json`), "projx-e2e", target);
+  }
+  if (components.includes("mobile")) {
+    const target = overrides?.mobile ?? `${nameSnake}_mobile`;
+    await replaceInFile(join2(dest, `${paths.mobile}/pubspec.yaml`), "projx_mobile", target);
+    await replaceInDir(join2(dest, `${paths.mobile}`), "package:projx_mobile/", `package:${target}/`, ".dart");
+  }
+}
+async function detectPackageNameOverrides(cwd, components, componentPaths) {
+  const overrides = {};
+  if (components.includes("fastapi")) {
+    const file = join2(cwd, componentPaths.fastapi, "pyproject.toml");
+    const name = await readTomlProjectName(file);
+    if (name) overrides.fastapi = name;
+  }
+  for (const c of ["fastify", "frontend", "e2e"]) {
+    if (!components.includes(c)) continue;
+    const file = join2(cwd, componentPaths[c], "package.json");
+    const name = await readJsonName(file);
+    if (name) overrides[c] = name;
+  }
+  if (components.includes("mobile")) {
+    const file = join2(cwd, componentPaths.mobile, "pubspec.yaml");
+    const name = await readPubspecName(file);
+    if (name) overrides.mobile = name;
+  }
+  return overrides;
+}
+async function readTomlProjectName(file) {
+  if (!existsSync(file)) return null;
+  try {
+    const content = await readFile2(file, "utf-8");
+    const match = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function readJsonName(file) {
+  if (!existsSync(file)) return null;
+  try {
+    const data = JSON.parse(await readFile2(file, "utf-8"));
+    return typeof data.name === "string" ? data.name : null;
+  } catch {
+    return null;
+  }
+}
+async function readPubspecName(file) {
+  if (!existsSync(file)) return null;
+  try {
+    const content = await readFile2(file, "utf-8");
+    const match = content.match(/^\s*name\s*:\s*([A-Za-z0-9_]+)/m);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function applyTemplate(cwd, repoDir, components, componentPaths, vars, version, componentSkips, rootSkip, applyDefaults = false) {
+  const hasHead = (() => {
+    try {
+      execSync("git rev-parse HEAD", { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!hasHead) {
+    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, {
+      componentSkips,
+      rootSkip,
+      applyDefaults,
+      realCwd: cwd
+    });
+    return { status: "clean" };
+  }
+  const { worktree, branch } = createOrphanWorktree(cwd);
+  try {
+    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, {
+      componentSkips,
+      rootSkip,
+      applyDefaults,
+      realCwd: cwd
+    });
+    execSync("git add -A", { cwd: worktree, stdio: "pipe" });
+    const diff = execSync("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
+    if (!diff) {
+      cleanupWorktree(cwd, worktree, branch);
+      return { status: "clean" };
+    }
+    execSync(
+      `git -c core.hooksPath=/dev/null commit -m "projx: template v${version} [${components.join(", ")}]"`,
+      { cwd: worktree, stdio: "pipe" }
+    );
+    try {
+      execSync(`git worktree remove "${worktree}" --force`, { cwd, stdio: "pipe" });
+    } catch {
+      try {
+        await rm(worktree, { recursive: true, force: true });
+        execSync("git worktree prune", { cwd, stdio: "pipe" });
+      } catch {
+      }
+    }
+    let mergeClean = false;
+    try {
+      execSync(
+        `git merge ${branch} --allow-unrelated-histories -m "projx: update to template v${version}"`,
+        { cwd, stdio: "pipe" }
+      );
+      mergeClean = true;
+    } catch {
+      try {
+        execSync("git merge --abort", { cwd, stdio: "pipe" });
+      } catch {
+      }
+    }
+    try {
+      execSync(`git branch -D ${branch}`, { cwd, stdio: "pipe" });
+    } catch {
+    }
+    if (mergeClean) {
+      await migrateComponentMarkers(cwd, components, componentPaths, applyDefaults);
+      saveBaselineRef(cwd);
+      return { status: "clean" };
+    }
+    const baselineRef = getBaselineRef(cwd);
+    if (baselineRef) {
+      const tmpTemplate = join2(tmpdir(), `projx-tpl-${Date.now()}`);
+      await mkdir(tmpTemplate, { recursive: true });
+      await writeTemplateToDir(tmpTemplate, repoDir, components, componentPaths, vars, version, {
+        componentSkips,
+        rootSkip,
+        applyDefaults,
+        realCwd: cwd
+      });
+      const result = await tryThreeWayMerge(cwd, tmpTemplate, baselineRef, componentPaths);
+      await rm(tmpTemplate, { recursive: true, force: true });
+      await migrateComponentMarkers(cwd, components, componentPaths, applyDefaults);
+      if (result.conflicted.length === 0) {
+        await writeManagedProjx(cwd, version, vars, applyDefaults);
+        execSync("git add -A", { cwd, stdio: "pipe" });
+        const staged = execSync("git diff --cached --stat", { cwd, stdio: "pipe" }).toString().trim();
+        if (staged) {
+          try {
+            execSync(
+              `git commit -m "projx: update to template v${version} (3-way merge)"`,
+              { cwd, stdio: "pipe" }
+            );
+          } catch (err) {
+            throw new Error(
+              `Pre-commit hook rejected the merged template content. Resolve the issues and commit manually:
+  git commit -m "projx: update to template v${version} (3-way merge)"`,
+              { cause: err }
+            );
+          }
+        }
+        saveBaselineRef(cwd);
+        return result.merged.length > 0 ? { status: "merged", mergedFiles: result.merged } : { status: "clean" };
+      }
+      await writeManagedProjx(cwd, version, vars, applyDefaults);
+      for (const f of result.merged) {
+        try {
+          execSync(`git add "${f}"`, { cwd, stdio: "pipe" });
+        } catch {
+        }
+      }
+      execSync("git add .projx", { cwd, stdio: "pipe" });
+      for (const component of components) {
+        const dir = componentPaths[component];
+        const markerRel = `${dir}/.projx-component`;
+        if (existsSync(join2(cwd, markerRel))) {
+          try {
+            execSync(`git add "${markerRel}"`, { cwd, stdio: "pipe" });
+          } catch {
+          }
+        }
+      }
+      return {
+        status: "conflicts",
+        mergedFiles: result.merged,
+        conflictedFiles: result.conflicted
+      };
+    }
+    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, {
+      componentSkips,
+      rootSkip,
+      applyDefaults,
+      realCwd: cwd
+    });
+    await migrateComponentMarkers(cwd, components, componentPaths, applyDefaults);
+    return { status: "conflicts" };
+  } catch (err) {
+    cleanupWorktree(cwd, worktree, branch);
+    throw err;
+  }
+}
+
+export {
+  buildPathsUpper,
+  buildDisplayNames,
+  BASELINE_REF,
+  matchesSkip,
+  saveBaselineRef,
+  getBaselineRef,
+  getFileAtRef,
+  collectAllFiles,
+  writeTemplateToDir,
+  detectPackageNameOverrides,
+  applyTemplate
+};