create-projx 1.3.5 → 1.3.6

package/README.md

@@ -87,19 +87,17 @@ cd my-app
 npx create-projx@latest update
 ```
 
-If the template merges cleanly with your code, it's auto-committed — done. If there are differences, template files are written directly and you review with `git diff`:
+Updates use a 3-tier merge strategy:
 
-```bash
-git diff                              # see what changed
-git checkout -- path/to/file          # discard a change you don't want
-git add . && git commit -m "projx: update to vX.X.X"  # commit when ready
-```
+1. **Git merge** — if the template merges cleanly with your code, it's auto-committed. Done.
+2. **3-way merge** — if git merge fails, each file is merged individually using `git merge-file`. Your additions (extra deps, env vars, custom config) are preserved alongside template updates. Clean merges are auto-staged; only true conflicts need review.
+3. **Direct copy** — if no merge baseline exists, template files are written directly. You pick which changes to keep via an interactive prompt, and discarded files are automatically added to your skip list.
 
 Your custom files (controllers, pages, middleware) are never deleted. Files you created that don't exist in the template are always preserved.
 
 ### Skip Files
 
-If a file keeps getting overwritten on every update, add it to `.projx-component`:
+To skip component source files, add `skip` to `.projx-component`:
 
 ```json
 {
@@ -109,7 +107,17 @@ If a file keeps getting overwritten on every update, add it to `.projx-component
 }
 ```
 
-Skipped files are excluded from template updates. Tooling files (Dockerfile, eslint, tsconfig) still get updated.
+To skip root-level files (docker-compose, README), add `skip` to `.projx`:
+
+```json
+{
+  "version": "1.3.6",
+  "components": ["fastapi", "frontend"],
+  "skip": ["docker-compose.yml", "README.md"]
+}
+```
+
+Skipped files are excluded from template updates.
 
 ## Options
 

package/dist/index.js

@@ -330,13 +330,13 @@ async function runPrompts(nameArg) {
 
 // src/scaffold.ts
 import { copyFileSync, existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile4 } from "fs/promises";
 import { join as join4 } from "path";
 import * as p2 from "@clack/prompts";
 
 // src/baseline.ts
-import { existsSync as existsSync2 } from "fs";
-import { chmod, mkdir as mkdir2, writeFile as writeFile2, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync2, writeFileSync, unlinkSync } from "fs";
+import { chmod, mkdir as mkdir2, writeFile as writeFile2, rm as rm2, readFile as readFile3 } from "fs/promises";
 import { execSync as execSync2 } from "child_process";
 import { join as join3 } from "path";
 import { tmpdir as tmpdir2 } from "os";
@@ -401,6 +401,7 @@ function generateVscodeSettings(vars) {
 }
 
 // src/baseline.ts
+var BASELINE_REF = "refs/projx/baseline";
 function matchesSkip(filePath, patterns) {
   for (const pattern of patterns) {
     if (pattern === "**") return true;
@@ -425,6 +426,98 @@ function matchesSkip(filePath, patterns) {
   }
   return false;
 }
+function saveBaselineRef(cwd) {
+  try {
+    const head = execSync2("git rev-parse HEAD", { cwd, stdio: "pipe" }).toString().trim();
+    execSync2(`git update-ref ${BASELINE_REF} ${head}`, { cwd, stdio: "pipe" });
+  } catch {
+  }
+}
+function getBaselineRef(cwd) {
+  try {
+    return execSync2(`git rev-parse --verify ${BASELINE_REF}`, { cwd, stdio: "pipe" }).toString().trim();
+  } catch {
+  }
+  try {
+    const sha = execSync2("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 execSync2(`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 = join3(tmpdir2(), `projx-base-${id}`);
+  const theirsTmp = join3(tmpdir2(), `projx-theirs-${id}`);
+  try {
+    writeFileSync(baseTmp, baseContent);
+    writeFileSync(theirsTmp, theirsContent);
+    execSync2(`git merge-file "${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: readdir3 } = await import("fs/promises");
+  const results = [];
+  const walk = async (current) => {
+    const entries = await readdir3(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join3(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else {
+        results.push(full.slice(base.length + 1));
+      }
+    }
+  };
+  await walk(dir);
+  return results;
+}
+async function tryThreeWayMerge(cwd, templateDir, baselineRef) {
+  const templateFiles = await collectAllFiles(templateDir, templateDir);
+  const merged = [];
+  const conflicted = [];
+  for (const file of templateFiles) {
+    const oursPath = join3(cwd, file);
+    if (!existsSync2(oursPath)) continue;
+    const baseContent = getFileAtRef(cwd, baselineRef, file);
+    if (baseContent === null) continue;
+    let theirsContent;
+    try {
+      theirsContent = await readFile3(join3(templateDir, file), "utf-8");
+    } catch {
+      continue;
+    }
+    const oursContent = await readFile3(oursPath, "utf-8");
+    if (oursContent === baseContent) continue;
+    if (theirsContent === baseContent) 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}`;
@@ -456,7 +549,7 @@ function cleanupWorktree(cwd, worktree, branch) {
 }
 async function removeSkippedFiles(dir, skipPatterns) {
   if (skipPatterns.length === 0) return;
-  const { readdir: readdir3, unlink } = await import("fs/promises");
+  const { readdir: readdir3, unlink: unlink2 } = await import("fs/promises");
   const walk = async (current, base) => {
     const entries = await readdir3(current, { withFileTypes: true });
     for (const entry of entries) {
@@ -465,13 +558,13 @@ async function removeSkippedFiles(dir, skipPatterns) {
       if (entry.isDirectory()) {
         await walk(full, base);
       } else if (entry.name !== ".projx-component" && matchesSkip(rel, skipPatterns)) {
-        await unlink(full);
+        await unlink2(full);
       }
     }
   };
   await walk(dir, dir);
 }
-async function writeTemplateToDir(dest, repoDir, components, componentPaths, vars, version, origin, componentSkips) {
+async function writeTemplateToDir(dest, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip) {
   const name = vars.projectName;
   const nameSnake = toSnake(name);
   for (const component of components) {
@@ -494,21 +587,34 @@ async function writeTemplateToDir(dest, repoDir, components, componentPaths, var
   }
   await substituteNames(dest, components, componentPaths, name, nameSnake);
   const hasBackend = components.includes("fastapi") || components.includes("fastify");
+  const skip = rootSkip ?? [];
+  const shouldWrite = (file) => !matchesSkip(file, skip);
   if (hasBackend || components.includes("frontend")) {
-    await writeFile2(join3(dest, "docker-compose.yml"), await generateDockerCompose(vars));
-    await writeFile2(join3(dest, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
-  }
-  await writeFile2(join3(dest, "README.md"), await generateReadme(vars));
-  await mkdir2(join3(dest, ".githooks"), { recursive: true });
-  await writeFile2(join3(dest, ".githooks/pre-commit"), await generatePreCommit(vars));
-  await chmod(join3(dest, ".githooks/pre-commit"), 493);
-  await mkdir2(join3(dest, ".github/workflows"), { recursive: true });
-  await writeFile2(join3(dest, ".github/workflows/ci.yml"), await generateCiYml(vars));
-  await writeFile2(join3(dest, "setup.sh"), await generateSetupSh(vars));
-  await chmod(join3(dest, "setup.sh"), 493);
+    if (shouldWrite("docker-compose.yml"))
+      await writeFile2(join3(dest, "docker-compose.yml"), await generateDockerCompose(vars));
+    if (shouldWrite("docker-compose.dev.yml"))
+      await writeFile2(join3(dest, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
+  }
+  if (shouldWrite("README.md"))
+    await writeFile2(join3(dest, "README.md"), await generateReadme(vars));
+  if (shouldWrite(".githooks/pre-commit")) {
+    await mkdir2(join3(dest, ".githooks"), { recursive: true });
+    await writeFile2(join3(dest, ".githooks/pre-commit"), await generatePreCommit(vars));
+    await chmod(join3(dest, ".githooks/pre-commit"), 493);
+  }
+  if (shouldWrite(".github/workflows/ci.yml")) {
+    await mkdir2(join3(dest, ".github/workflows"), { recursive: true });
+    await writeFile2(join3(dest, ".github/workflows/ci.yml"), await generateCiYml(vars));
+  }
+  if (shouldWrite("setup.sh")) {
+    await writeFile2(join3(dest, "setup.sh"), await generateSetupSh(vars));
+    await chmod(join3(dest, "setup.sh"), 493);
+  }
   await copyStaticFiles(repoDir, dest);
-  await mkdir2(join3(dest, ".vscode"), { recursive: true });
-  await writeFile2(join3(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
+  if (shouldWrite(".vscode/settings.json")) {
+    await mkdir2(join3(dest, ".vscode"), { recursive: true });
+    await writeFile2(join3(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
+  }
   const projxConfig = {
     version,
     components,
@@ -534,7 +640,7 @@ async function substituteNames(dest, components, paths, name, nameSnake) {
     await replaceInDir(join3(dest, `${paths.mobile}`), "package:projx_mobile/", `package:${nameSnake}_mobile/`, ".dart");
   }
 }
-async function applyTemplate(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold", componentSkips) {
+async function applyTemplate(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold", componentSkips, rootSkip) {
   const hasHead = (() => {
     try {
       execSync2("git rev-parse HEAD", { cwd, stdio: "pipe" });
@@ -544,12 +650,12 @@ async function applyTemplate(cwd, repoDir, components, componentPaths, vars, ver
     }
   })();
   if (!hasHead) {
-    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips);
+    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
     return { status: "clean" };
   }
   const { worktree, branch } = createOrphanWorktree(cwd);
   try {
-    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips);
+    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
     execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
     const diff = execSync2("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
     if (!diff) {
@@ -587,9 +693,54 @@ async function applyTemplate(cwd, repoDir, components, componentPaths, vars, ver
     } catch {
     }
     if (mergeClean) {
+      saveBaselineRef(cwd);
       return { status: "clean" };
     }
-    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips);
+    const baselineRef = getBaselineRef(cwd);
+    if (baselineRef) {
+      const tmpTemplate = join3(tmpdir2(), `projx-tpl-${Date.now()}`);
+      await mkdir2(tmpTemplate, { recursive: true });
+      await writeTemplateToDir(tmpTemplate, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
+      const result = await tryThreeWayMerge(cwd, tmpTemplate, baselineRef);
+      await rm2(tmpTemplate, { recursive: true, force: true });
+      const projxConfig = {
+        version,
+        components,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      };
+      await writeFile2(join3(cwd, ".projx"), JSON.stringify(projxConfig, null, 2) + "\n");
+      if (result.conflicted.length === 0) {
+        execSync2("git add -A", { cwd, stdio: "pipe" });
+        const staged = execSync2("git diff --cached --stat", { cwd, stdio: "pipe" }).toString().trim();
+        if (staged) {
+          execSync2(
+            `git commit --no-verify -m "projx: update to template v${version} (3-way merge)"`,
+            { cwd, stdio: "pipe" }
+          );
+        }
+        saveBaselineRef(cwd);
+        return result.merged.length > 0 ? { status: "merged", mergedFiles: result.merged } : { status: "clean" };
+      }
+      for (const f of result.conflicted) {
+        try {
+          execSync2(`git checkout -- "${f}"`, { cwd, stdio: "pipe" });
+        } catch {
+        }
+      }
+      for (const f of result.merged) {
+        try {
+          execSync2(`git add "${f}"`, { cwd, stdio: "pipe" });
+        } catch {
+        }
+      }
+      execSync2("git add .projx", { cwd, stdio: "pipe" });
+      return {
+        status: "conflicts",
+        mergedFiles: result.merged,
+        conflictedFiles: result.conflicted
+      };
+    }
+    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips, rootSkip);
     return { status: "conflicts" };
   } catch (err) {
     cleanupWorktree(cwd, worktree, branch);
@@ -615,7 +766,7 @@ async function scaffold(opts, dest, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile3(join4(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile4(join4(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     p2.log.info(`Scaffolding project in ${dest}`);
     if (opts.git) {
@@ -634,6 +785,7 @@ async function scaffold(opts, dest, localRepo) {
       try {
         exec("git add -A", dest);
         exec('git commit --no-verify -m "Initial scaffold from projx"', dest);
+        saveBaselineRef(dest);
       } catch {
       }
     }
@@ -714,7 +866,7 @@ function copyEnvExamples(dest, components) {
 
 // src/update.ts
 import { existsSync as existsSync4, readFileSync } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile3, unlink } from "fs/promises";
 import { execSync as execSync3 } from "child_process";
 import { join as join5 } from "path";
 import * as p3 from "@clack/prompts";
@@ -736,7 +888,7 @@ async function update(cwd, localRepo) {
   const configPath = join5(cwd, ".projx");
   let config;
   if (existsSync4(configPath)) {
-    config = JSON.parse(await readFile4(configPath, "utf-8"));
+    config = JSON.parse(await readFile5(configPath, "utf-8"));
     p3.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
   } else {
     p3.log.warn("No .projx file found. Detecting components from directories.");
@@ -749,9 +901,9 @@ async function update(cwd, localRepo) {
     p3.log.info(`Detected: ${detected.join(", ")}`);
   }
   const componentPaths = await discoverComponentPaths(cwd, config.components);
-  const remapped = config.components.filter((c) => componentPaths[c] !== c);
-  for (const c of remapped) {
-    p3.log.info(`${c} \u2192 ${componentPaths[c]}/`);
+  for (const c of config.components) {
+    const dir = componentPaths[c];
+    p3.log.info(dir !== c ? `${c} \u2192 ${dir}/` : `${c}/`);
   }
   const componentSkips = {};
   for (const component of config.components) {
@@ -770,27 +922,41 @@ async function update(cwd, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile4(join5(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile5(join5(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     const name = detectProjectName(cwd, config.components, componentPaths);
     const vars = { projectName: name, components: config.components, paths: componentPaths };
     const spinner5 = p3.spinner();
     spinner5.start("Applying template update");
-    const result = await applyTemplate(cwd, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips);
+    const rootSkip = config.skip ?? [];
+    const result = await applyTemplate(cwd, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips, rootSkip);
     spinner5.stop("Template applied.");
-    if (result.status === "conflicts") {
-      p3.log.warn("Some template files differ from your code. Changes written directly.");
-      p3.log.info("Review changes:");
-      p3.log.info("  git diff");
-      p3.log.info("");
-      p3.log.info("Keep a change:  git add <file>");
-      p3.log.info("Discard a change:  git checkout -- <file>");
-      p3.log.info('Commit when ready:  git add . && git commit -m "projx: update to v' + version + '"');
-      p3.log.info("");
-      p3.log.info("To skip files on future updates, add to .projx-component:");
-      p3.log.info('  { "skip": ["src/**", "tests/**"] }');
-      p3.outro(`Template v${version} applied. Review with git diff.`);
+    if (result.status === "merged") {
+      saveBaselineRef(cwd);
+      p3.log.success(`${result.mergedFiles?.length ?? 0} file(s) merged cleanly.`);
+      p3.outro(`Updated to template v${version}.`);
+    } else if (result.status === "conflicts") {
+      if (result.mergedFiles && result.mergedFiles.length > 0) {
+        p3.log.success(`${result.mergedFiles.length} file(s) merged cleanly and staged.`);
+      }
+      const conflictCount = result.conflictedFiles?.length ?? 0;
+      if (conflictCount > 0) {
+        p3.log.warn(`${conflictCount} file(s) need review:`);
+        for (const f of result.conflictedFiles) {
+          p3.log.info(`  ${f}`);
+        }
+      }
+      const handled = await promptSkipLearning(cwd, componentPaths, version);
+      if (!handled) {
+        p3.log.info("");
+        p3.log.info("Review:  git diff");
+        p3.log.info("Keep:    git add <file>");
+        p3.log.info("Discard: git checkout -- <file>");
+        p3.log.info(`Commit:  git add . && git commit -m "projx: update to v${version}"`);
+        p3.outro(`Template v${version} applied. Review with git diff.`);
+      }
     } else {
+      saveBaselineRef(cwd);
       p3.outro(`Updated to template v${version}.`);
     }
   } catch (err) {
@@ -816,6 +982,101 @@ function hasUncommittedChanges(cwd) {
     return false;
   }
 }
+async function promptSkipLearning(cwd, componentPaths, version) {
+  if (!process.stdin.isTTY) return false;
+  const statusOutput = execSync3("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+  if (!statusOutput) return false;
+  const entries = statusOutput.split("\n").filter(Boolean).map((line) => ({
+    status: line.slice(0, 2).trim(),
+    file: line.slice(3).trim()
+  }));
+  const changedFiles = entries.map((e) => e.file).filter((f) => {
+    const base = f.split("/").pop();
+    if (base === ".projx" || base === COMPONENT_MARKER) return false;
+    return true;
+  });
+  if (changedFiles.length === 0) return false;
+  p3.log.warn(`${changedFiles.length} template file(s) differ from your code.`);
+  const selected = await p3.multiselect({
+    message: "Select files to KEEP (unselected will be discarded and skipped on future updates)",
+    options: changedFiles.map((f) => ({ value: f, label: f })),
+    required: false
+  });
+  if (p3.isCancel(selected)) return false;
+  const kept = new Set(selected);
+  const discarded = changedFiles.filter((f) => !kept.has(f));
+  if (discarded.length > 0) {
+    for (const file of discarded) {
+      const entry = entries.find((e) => e.file === file);
+      try {
+        if (entry?.status === "??") {
+          await unlink(join5(cwd, file));
+        } else {
+          execSync3(`git checkout -- "${file}"`, { cwd, stdio: "pipe" });
+        }
+      } catch {
+      }
+    }
+    await learnSkips(cwd, discarded, componentPaths);
+    p3.log.success(
+      `Discarded ${discarded.length} file(s) and added to skip list.`
+    );
+  }
+  if (kept.size > 0) {
+    p3.log.info(`${kept.size} file(s) kept \u2014 commit when ready:`);
+    p3.log.info(
+      `  git add . && git commit -m "projx: update to v${version}"`
+    );
+    p3.outro(`Template v${version} applied.`);
+  } else {
+    p3.outro("All template changes discarded. Skip list updated.");
+  }
+  return true;
+}
+async function learnSkips(cwd, files, componentPaths) {
+  const componentSkipAdds = {};
+  const rootSkipAdds = [];
+  const dirToComponent = {};
+  for (const [component, dir] of Object.entries(componentPaths)) {
+    dirToComponent[dir] = component;
+  }
+  for (const file of files) {
+    let matched = false;
+    for (const [dir, component] of Object.entries(dirToComponent)) {
+      if (file.startsWith(dir + "/")) {
+        const relative = file.slice(dir.length + 1);
+        if (!componentSkipAdds[component]) componentSkipAdds[component] = [];
+        componentSkipAdds[component].push(relative);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      rootSkipAdds.push(file);
+    }
+  }
+  for (const [component, additions] of Object.entries(componentSkipAdds)) {
+    const dir = componentPaths[component];
+    const markerPath = join5(cwd, dir, COMPONENT_MARKER);
+    try {
+      const data = JSON.parse(await readFile5(markerPath, "utf-8"));
+      const existing = data.skip ?? [];
+      data.skip = [.../* @__PURE__ */ new Set([...existing, ...additions])];
+      await writeFile3(markerPath, JSON.stringify(data, null, 2) + "\n");
+    } catch {
+    }
+  }
+  if (rootSkipAdds.length > 0) {
+    const configPath = join5(cwd, ".projx");
+    try {
+      const data = JSON.parse(await readFile5(configPath, "utf-8"));
+      const existing = data.skip ?? [];
+      data.skip = [.../* @__PURE__ */ new Set([...existing, ...rootSkipAdds])];
+      await writeFile3(configPath, JSON.stringify(data, null, 2) + "\n");
+    } catch {
+    }
+  }
+}
 function detectProjectName(cwd, components, componentPaths) {
   for (const component of components) {
     const dir = componentPaths[component] ?? component;
@@ -836,7 +1097,7 @@ function detectProjectName(cwd, components, componentPaths) {
 
 // src/add.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { join as join6 } from "path";
 import * as p4 from "@clack/prompts";
 async function add(cwd, newComponents, localRepo, skipInstall = false) {
@@ -847,7 +1108,7 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
     p4.log.error("No .projx file found. Run 'npx create-projx <name>' to create a project first.");
     process.exit(1);
   }
-  const config = JSON.parse(await readFile5(configPath, "utf-8"));
+  const config = JSON.parse(await readFile6(configPath, "utf-8"));
   const existing = config.components;
   const alreadyExists = newComponents.filter((c) => existing.includes(c));
   if (alreadyExists.length > 0) {
@@ -874,7 +1135,7 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
     for (const c of toAdd) paths[c] = c;
     const name = detectProjectName2(cwd, existing, paths);
     const vars = { projectName: name, components: allComponents, paths };
-    const pkg = JSON.parse(await readFile5(join6(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile6(join6(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     const spinner5 = p4.spinner();
     spinner5.start("Adding components");
@@ -972,7 +1233,7 @@ function detectProjectName2(cwd, components, paths) {
 
 // src/init.ts
 import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { execSync as execSync4 } from "child_process";
 import { join as join8 } from "path";
 import * as p5 from "@clack/prompts";
@@ -1108,7 +1369,7 @@ async function init(cwd, localRepo) {
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    const pkg = JSON.parse(await readFile6(join8(repoDir, "cli/package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile7(join8(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
     const applySpinner = p5.spinner();
     applySpinner.start("Applying template");
@@ -1120,6 +1381,9 @@ async function init(cwd, localRepo) {
       } catch {
       }
     }
+    if (result.status === "clean" || result.status === "merged") {
+      saveBaselineRef(cwd);
+    }
     if (result.status === "conflicts") {
       p5.log.warn("Some template files differ from your code. Changes written directly.");
       p5.log.info("Review changes:");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-projx",
-  "version": "1.3.5",
+  "version": "1.3.6",
   "description": "Scaffold production-grade fullstack projects in seconds. FastAPI, Fastify, React, Flutter, Terraform — with auth, database, CI/CD, E2E tests, and Docker. One command, ready to deploy.",
   "type": "module",
   "bin": {