create-projx 1.3.4 → 1.3.5

package/README.md

@@ -87,24 +87,30 @@ cd my-app
 npx create-projx@latest update
 ```
 
-Uses a `projx/baseline` branch that tracks the raw template state. When you update, the baseline advances to the new template version and merges into your branch using git's three-way merge:
-
-- **Files only the template changed** — auto-merged, no action needed
-- **Files only you changed** — preserved, untouched
-- **Files both sides changed** — git conflict, you resolve
+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`:
 
 ```bash
-# If conflicts occur:
-git status                    # see conflicted files
-# resolve conflicts in your editor
-git add . && git commit       # finish the merge
-
-# Or abort:
-git merge --abort
+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
 ```
 
 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`:
+
+```json
+{
+  "components": ["fastapi"],
+  "origin": "init",
+  "skip": ["src/**", "tests/**"]
+}
+```
+
+Skipped files are excluded from template updates. Tooling files (Dockerfile, eslint, tsconfig) still get updated.
+
 ## Options
 
 ```

package/dist/index.js

@@ -130,11 +130,6 @@ async function copyStaticFiles(repoDir, dest) {
       manifest.push(file);
     }
   }
-  const gitignore = join(tpl, ".gitignore");
-  if (existsSync(gitignore)) {
-    await cp(gitignore, join(dest, ".gitignore"));
-    manifest.push(".gitignore");
-  }
   const extensionsJson = join(tpl, ".vscode/extensions.json");
   if (existsSync(extensionsJson)) {
     await mkdir(join(dest, ".vscode"), { recursive: true });
@@ -282,8 +277,8 @@ function render(template, vars) {
       (_, expr) => {
         const parts = expr.split(".");
         let val = vars;
-        for (const p7 of parts) {
-          val = val?.[p7];
+        for (const p6 of parts) {
+          val = val?.[p6];
         }
         return String(val ?? "");
       }
@@ -337,7 +332,7 @@ async function runPrompts(nameArg) {
 import { copyFileSync, existsSync as existsSync3 } from "fs";
 import { mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
 import { join as join4 } from "path";
-import * as p3 from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 
 // src/baseline.ts
 import { existsSync as existsSync2 } from "fs";
@@ -345,7 +340,6 @@ import { chmod, mkdir as mkdir2, writeFile as writeFile2, rm as rm2 } from "fs/p
 import { execSync as execSync2 } from "child_process";
 import { join as join3 } from "path";
 import { tmpdir as tmpdir2 } from "os";
-import * as p2 from "@clack/prompts";
 
 // src/generators/index.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -407,47 +401,6 @@ function generateVscodeSettings(vars) {
 }
 
 // src/baseline.ts
-var BASELINE_BRANCH = "projx/baseline";
-function hasBaseline(cwd) {
-  try {
-    execSync2(`git show-ref --verify --quiet refs/heads/${BASELINE_BRANCH}`, {
-      cwd,
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createWorktree(cwd, branch, orphan) {
-  const worktree = join3(tmpdir2(), `projx-baseline-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  if (orphan) {
-    execSync2(`git worktree add --orphan -b ${branch} "${worktree}"`, {
-      cwd,
-      stdio: "pipe"
-    });
-  } else {
-    execSync2(`git worktree add "${worktree}" ${branch}`, {
-      cwd,
-      stdio: "pipe"
-    });
-  }
-  return worktree;
-}
-function removeWorktree(cwd, worktree) {
-  try {
-    execSync2(`git worktree remove "${worktree}" --force`, {
-      cwd,
-      stdio: "pipe"
-    });
-  } catch {
-    try {
-      rm2(worktree, { recursive: true, force: true });
-      execSync2("git worktree prune", { cwd, stdio: "pipe" });
-    } catch {
-    }
-  }
-}
 function matchesSkip(filePath, patterns) {
   for (const pattern of patterns) {
     if (pattern === "**") return true;
@@ -472,6 +425,35 @@ function matchesSkip(filePath, patterns) {
   }
   return false;
 }
+function createOrphanWorktree(cwd) {
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const branch = `projx/tmp-${id}`;
+  const worktree = join3(tmpdir2(), `projx-wt-${id}`);
+  try {
+    execSync2("git worktree prune", { cwd, stdio: "pipe" });
+  } catch {
+  }
+  execSync2(`git worktree add --orphan -b ${branch} "${worktree}"`, {
+    cwd,
+    stdio: "pipe"
+  });
+  return { worktree, branch };
+}
+function cleanupWorktree(cwd, worktree, branch) {
+  try {
+    execSync2(`git worktree remove "${worktree}" --force`, { cwd, stdio: "pipe" });
+  } catch {
+    try {
+      rm2(worktree, { recursive: true, force: true });
+      execSync2("git worktree prune", { cwd, stdio: "pipe" });
+    } catch {
+    }
+  }
+  try {
+    execSync2(`git branch -D ${branch}`, { cwd, stdio: "pipe" });
+  } catch {
+  }
+}
 async function removeSkippedFiles(dir, skipPatterns) {
   if (skipPatterns.length === 0) return;
   const { readdir: readdir3, unlink } = await import("fs/promises");
@@ -494,22 +476,20 @@ async function writeTemplateToDir(dest, repoDir, components, componentPaths, var
   const nameSnake = toSnake(name);
   for (const component of components) {
     const targetDir = componentPaths[component];
-    if (targetDir === component) {
-      await copyComponent(repoDir, component, dest);
-    } else {
-      await copyComponent(repoDir, component, join3(dest, "__tmp__"));
-      const { cp: cp2 } = await import("fs/promises");
-      const srcDir = join3(dest, "__tmp__", component);
-      const outDir = join3(dest, targetDir);
-      if (existsSync2(srcDir)) {
-        await cp2(srcDir, outDir, { recursive: true, force: true });
-      }
-      await rm2(join3(dest, "__tmp__"), { recursive: true, force: true });
-    }
     const skipPatterns = componentSkips?.[component] ?? [];
+    const tmpDir = join3(dest, "__cptmp__");
+    await copyComponent(repoDir, component, tmpDir);
+    const srcDir = join3(tmpDir, component);
     if (skipPatterns.length > 0) {
-      await removeSkippedFiles(join3(dest, targetDir), skipPatterns);
+      await removeSkippedFiles(srcDir, skipPatterns);
+    }
+    const outDir = join3(dest, targetDir);
+    await mkdir2(outDir, { recursive: true });
+    const { cp: cp2 } = await import("fs/promises");
+    if (existsSync2(srcDir)) {
+      await cp2(srcDir, outDir, { recursive: true, force: true });
     }
+    await rm2(tmpDir, { recursive: true, force: true });
     await writeComponentMarker(join3(dest, targetDir), component, origin, skipPatterns.length > 0 ? skipPatterns : void 0);
   }
   await substituteNames(dest, components, componentPaths, name, nameSnake);
@@ -532,11 +512,7 @@ async function writeTemplateToDir(dest, repoDir, components, componentPaths, var
   const projxConfig = {
     version,
     components,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-    baseline: {
-      branch: BASELINE_BRANCH,
-      templateVersion: version
-    }
+    createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
   };
   await writeFile2(join3(dest, ".projx"), JSON.stringify(projxConfig, null, 2) + "\n");
 }
@@ -558,90 +534,68 @@ async function substituteNames(dest, components, paths, name, nameSnake) {
     await replaceInDir(join3(dest, `${paths.mobile}`), "package:projx_mobile/", `package:${nameSnake}_mobile/`, ".dart");
   }
 }
-async function createBaseline(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold", componentSkips) {
-  const worktree = createWorktree(cwd, BASELINE_BRANCH, true);
-  try {
-    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips);
-    execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
-    execSync2(
-      `git commit --no-verify -m "projx: baseline template v${version} [${components.join(", ")}]"`,
-      { cwd: worktree, stdio: "pipe" }
-    );
-  } finally {
-    removeWorktree(cwd, worktree);
+async function applyTemplate(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold", componentSkips) {
+  const hasHead = (() => {
+    try {
+      execSync2("git rev-parse HEAD", { cwd, stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!hasHead) {
+    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips);
+    return { status: "clean" };
   }
-}
-async function updateBaseline(cwd, repoDir, components, componentPaths, vars, version, componentSkips) {
-  const worktree = createWorktree(cwd, BASELINE_BRANCH, false);
+  const { worktree, branch } = createOrphanWorktree(cwd);
   try {
-    execSync2("git rm -rf .", { cwd: worktree, stdio: "pipe" });
-    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, "scaffold", componentSkips);
+    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin, componentSkips);
     execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
     const diff = execSync2("git diff --cached --stat", { cwd: worktree, stdio: "pipe" }).toString().trim();
     if (!diff) {
-      return { changed: false };
+      cleanupWorktree(cwd, worktree, branch);
+      return { status: "clean" };
     }
     execSync2(
-      `git commit --no-verify -m "projx: update baseline to template v${version}"`,
+      `git commit --no-verify -m "projx: template v${version} [${components.join(", ")}]"`,
       { cwd: worktree, stdio: "pipe" }
     );
-    return { changed: true };
-  } finally {
-    removeWorktree(cwd, worktree);
-  }
-}
-async function addToBaseline(cwd, repoDir, newComponents, allComponents, componentPaths, vars, version) {
-  const worktree = createWorktree(cwd, BASELINE_BRANCH, false);
-  try {
-    await writeTemplateToDir(worktree, repoDir, allComponents, componentPaths, vars, version, "scaffold");
-    execSync2("git add -A", { cwd: worktree, stdio: "pipe" });
-    execSync2(
-      `git commit --no-verify -m "projx: add ${newComponents.join(", ")} template v${version}"`,
-      { cwd: worktree, stdio: "pipe" }
-    );
-  } finally {
-    removeWorktree(cwd, worktree);
-  }
-}
-function mergeBaseline(cwd, message, allowUnrelated = false, oursOnConflict = false) {
-  const args2 = [`git merge ${BASELINE_BRANCH}`];
-  args2.push(`-m "${message}"`);
-  if (allowUnrelated) args2.push("--allow-unrelated-histories");
-  if (oursOnConflict) {
     try {
-      execSync2(`${args2.join(" ")} --no-commit`, { cwd, stdio: "pipe" });
+      execSync2(`git worktree remove "${worktree}" --force`, { cwd, stdio: "pipe" });
     } catch {
+      try {
+        await rm2(worktree, { recursive: true, force: true });
+        execSync2("git worktree prune", { cwd, stdio: "pipe" });
+      } catch {
+      }
     }
-    execSync2("git checkout --ours .", { cwd, stdio: "pipe" });
-    execSync2("git add -A", { cwd, stdio: "pipe" });
-    execSync2(`git commit --no-verify --no-edit -m "${message}"`, { cwd, stdio: "pipe" });
-    return { status: "clean" };
-  }
-  try {
-    execSync2(args2.join(" "), { cwd, stdio: "pipe" });
-    return { status: "clean" };
-  } catch {
-    const conflicted = execSync2("git diff --name-only --diff-filter=U", { cwd, stdio: "pipe" }).toString().trim();
-    if (!conflicted) {
+    let mergeClean = false;
+    try {
+      execSync2(
+        `git merge ${branch} --allow-unrelated-histories -m "projx: update to template v${version}"`,
+        { cwd, stdio: "pipe" }
+      );
+      mergeClean = true;
+    } catch {
+      try {
+        execSync2("git merge --abort", { cwd, stdio: "pipe" });
+      } catch {
+      }
+    }
+    try {
+      execSync2(`git branch -D ${branch}`, { cwd, stdio: "pipe" });
+    } catch {
+    }
+    if (mergeClean) {
       return { status: "clean" };
     }
-    return {
-      status: "conflicts",
-      conflictedFiles: conflicted.split("\n").filter(Boolean)
-    };
+    await writeTemplateToDir(cwd, repoDir, components, componentPaths, vars, version, origin, componentSkips);
+    return { status: "conflicts" };
+  } catch (err) {
+    cleanupWorktree(cwd, worktree, branch);
+    throw err;
   }
 }
-async function reconstructBaseline(cwd, repoDir, components, componentPaths, vars, version, componentSkips) {
-  p2.log.warn("projx/baseline branch not found. Reconstructing...");
-  await createBaseline(cwd, repoDir, components, componentPaths, vars, version, "scaffold", componentSkips);
-  mergeBaseline(
-    cwd,
-    `projx: reconstructed baseline for template v${version}`,
-    true,
-    true
-  );
-  p2.log.success("Baseline reconstructed.");
-}
 
 // src/scaffold.ts
 async function scaffold(opts, dest, localRepo) {
@@ -652,39 +606,26 @@ async function scaffold(opts, dest, localRepo) {
   const vars = { projectName: name, components: opts.components, paths };
   const isLocal = !!localRepo;
   await mkdir3(dest, { recursive: true });
-  const dlSpinner = p3.spinner();
+  const dlSpinner = p2.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p3.log.error(String(err));
+    p2.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(await readFile3(join4(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    p3.log.info(`Scaffolding project in ${dest}`);
+    p2.log.info(`Scaffolding project in ${dest}`);
     if (opts.git) {
       exec("git init", dest);
       exec("git config core.hooksPath .githooks", dest);
-      const spinner5 = p3.spinner();
-      spinner5.start("Creating baseline and scaffold");
-      await createBaseline(dest, repoDir, opts.components, paths, vars, version);
-      const result = mergeBaseline(
-        dest,
-        `projx: initial scaffold from template v${version}`,
-        true
-      );
-      spinner5.stop("Scaffold complete.");
-      if (result.status === "conflicts") {
-        p3.log.warn("Unexpected conflicts during scaffold \u2014 this shouldn't happen.");
-      }
-    } else {
-      const spinner5 = p3.spinner();
-      spinner5.start("Copying template files");
-      await createBaseline(dest, repoDir, opts.components, paths, vars, version);
-      spinner5.stop("Template files copied.");
     }
+    const spinner5 = p2.spinner();
+    spinner5.start("Scaffolding project");
+    await applyTemplate(dest, repoDir, opts.components, paths, vars, version);
+    spinner5.stop("Scaffold complete.");
     if (opts.install) {
       await installDeps(dest, opts.components);
     }
@@ -699,7 +640,7 @@ async function scaffold(opts, dest, localRepo) {
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p3.outro(`Done! Next steps:
+  p2.outro(`Done! Next steps:
 
   cd ${name}
   ./setup.sh
@@ -708,7 +649,7 @@ async function scaffold(opts, dest, localRepo) {
 }
 async function installDeps(dest, components) {
   for (const component of components) {
-    const spinner5 = p3.spinner();
+    const spinner5 = p2.spinner();
     try {
       switch (component) {
         case "fastapi":
@@ -717,7 +658,7 @@ async function installDeps(dest, components) {
             exec("uv sync --all-extras", join4(dest, "fastapi"));
             spinner5.stop("FastAPI dependencies installed.");
           } else {
-            p3.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
+            p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
@@ -747,7 +688,7 @@ async function installDeps(dest, components) {
             exec("flutter pub get", join4(dest, "mobile"));
             spinner5.stop("Flutter dependencies installed.");
           } else {
-            p3.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
+            p2.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
           break;
         case "infra":
@@ -776,49 +717,55 @@ import { existsSync as existsSync4, readFileSync } from "fs";
 import { readFile as readFile4 } from "fs/promises";
 import { execSync as execSync3 } from "child_process";
 import { join as join5 } from "path";
-import * as p4 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 async function update(cwd, localRepo) {
-  p4.intro("projx update");
+  p3.intro("projx update");
   const isLocal = !!localRepo;
   if (!isGitRepo(cwd)) {
-    p4.log.error(`projx update requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
+    p3.log.error("projx update requires a git repo.");
     process.exit(1);
   }
+  try {
+    execSync3("git worktree prune", { cwd, stdio: "pipe" });
+  } catch {
+  }
   if (hasUncommittedChanges(cwd)) {
-    p4.log.error("You have uncommitted changes. Commit or stash them first.");
+    p3.log.error("You have uncommitted changes. Commit or stash them first.");
     process.exit(1);
   }
   const configPath = join5(cwd, ".projx");
   let config;
   if (existsSync4(configPath)) {
     config = JSON.parse(await readFile4(configPath, "utf-8"));
-    p4.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
+    p3.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
   } else {
-    p4.log.warn("No .projx file found. Detecting components from directories.");
+    p3.log.warn("No .projx file found. Detecting components from directories.");
     const detected = COMPONENTS.filter((c) => existsSync4(join5(cwd, c)));
     if (detected.length === 0) {
-      p4.log.error("No projx components found. Run 'projx init' first.");
+      p3.log.error("No projx components found. Run 'projx init' first.");
       process.exit(1);
     }
-    config = {
-      version: "0.0.0",
-      components: detected,
-      createdAt: "unknown"
-    };
-    p4.log.info(`Detected: ${detected.join(", ")}`);
+    config = { version: "0.0.0", components: detected, createdAt: "unknown" };
+    p3.log.info(`Detected: ${detected.join(", ")}`);
   }
   const componentPaths = await discoverComponentPaths(cwd, config.components);
   const remapped = config.components.filter((c) => componentPaths[c] !== c);
-  if (remapped.length > 0) {
-    for (const c of remapped) {
-      p4.log.info(`${c} \u2192 ${componentPaths[c]}/`);
+  for (const c of remapped) {
+    p3.log.info(`${c} \u2192 ${componentPaths[c]}/`);
+  }
+  const componentSkips = {};
+  for (const component of config.components) {
+    const dir = componentPaths[component];
+    const marker = await readComponentMarker(join5(cwd, dir));
+    if (marker?.skip && marker.skip.length > 0) {
+      componentSkips[component] = marker.skip;
     }
   }
-  const dlSpinner = p4.spinner();
+  const dlSpinner = p3.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p4.log.error(String(err));
+    p3.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
@@ -827,73 +774,27 @@ async function update(cwd, localRepo) {
     const version = pkg.version;
     const name = detectProjectName(cwd, config.components, componentPaths);
     const vars = { projectName: name, components: config.components, paths: componentPaths };
-    const componentSkips = {};
-    for (const component of config.components) {
-      const dir = componentPaths[component];
-      const marker = await readComponentMarker(join5(cwd, dir));
-      if (marker?.skip && marker.skip.length > 0) {
-        componentSkips[component] = marker.skip;
-      } else if (marker?.origin === "init" || !marker?.origin) {
-        componentSkips[component] = ["**"];
-      }
-    }
-    if (!hasBaseline(cwd)) {
-      const rebuildSpinner = p4.spinner();
-      rebuildSpinner.start("Establishing baseline (first-time migration)");
-      await reconstructBaseline(cwd, repoDir, config.components, componentPaths, vars, config.version || version, componentSkips);
-      rebuildSpinner.stop("Baseline established.");
-    }
-    const updateSpinner = p4.spinner();
-    updateSpinner.start("Updating baseline to latest template");
-    const { changed } = await updateBaseline(cwd, repoDir, config.components, componentPaths, vars, version, componentSkips);
-    if (!changed) {
-      updateSpinner.stop("Already up to date.");
-      p4.outro("No template changes to apply.");
-      return;
-    }
-    updateSpinner.stop("Baseline updated.");
-    const mergeSpinner = p4.spinner();
-    mergeSpinner.start("Merging template changes");
-    const result = mergeBaseline(cwd, `projx: update to template v${version}`);
-    mergeSpinner.stop("Merge complete.");
-    if (result.status === "clean") {
-      const { writeFile: writeFile3 } = await import("fs/promises");
-      const updatedConfig = {
-        ...config,
-        version,
-        baseline: { branch: "projx/baseline", templateVersion: version }
-      };
-      await writeFile3(join5(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2) + "\n");
-      for (const component of config.components) {
-        const dir = componentPaths[component];
-        const skip = componentSkips[component];
-        await writeComponentMarker(
-          join5(cwd, dir),
-          component,
-          skip?.includes("**") ? "init" : "scaffold",
-          skip
-        );
-      }
-      execSync3('git add -A && git commit --no-verify -m "projx: post-update config"', { cwd, stdio: "pipe" });
-    }
+    const spinner5 = p3.spinner();
+    spinner5.start("Applying template update");
+    const result = await applyTemplate(cwd, repoDir, config.components, componentPaths, vars, version, "scaffold", componentSkips);
+    spinner5.stop("Template applied.");
     if (result.status === "conflicts") {
-      p4.log.warn(`Merge conflicts in ${result.conflictedFiles.length} file(s):`);
-      for (const f of result.conflictedFiles) {
-        p4.log.message(`  ${f}`);
-      }
-      p4.outro(
-        "Resolve conflicts, then:\n  git add . && git commit\n\nOr abort:\n  git merge --abort"
-      );
+      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.`);
     } else {
-      p4.outro(`Updated to template v${version}. All changes merged cleanly.`);
+      p3.outro(`Updated to template v${version}.`);
     }
   } catch (err) {
-    try {
-      execSync3("git merge --abort", { cwd, stdio: "pipe" });
-    } catch {
-    }
-    p4.log.error(`Update failed: ${err}`);
-    p4.log.info("Your code is safe. Run 'git merge --abort' if needed.");
+    p3.log.error(`Update failed: ${err}`);
     process.exit(1);
   } finally {
     await cleanupRepo(repoDir, isLocal);
@@ -937,32 +838,32 @@ function detectProjectName(cwd, components, componentPaths) {
 import { copyFileSync as copyFileSync2, existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
 import { join as join6 } from "path";
-import * as p5 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 async function add(cwd, newComponents, localRepo, skipInstall = false) {
-  p5.intro("projx add");
+  p4.intro("projx add");
   const isLocal = !!localRepo;
   const configPath = join6(cwd, ".projx");
   if (!existsSync5(configPath)) {
-    p5.log.error("No .projx file found. Run 'projx <name>' to create a project first.");
+    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 existing = config.components;
   const alreadyExists = newComponents.filter((c) => existing.includes(c));
   if (alreadyExists.length > 0) {
-    p5.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
+    p4.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
   }
   const toAdd = newComponents.filter((c) => !existing.includes(c));
   if (toAdd.length === 0) {
-    p5.log.info("Nothing new to add.");
+    p4.log.info("Nothing new to add.");
     process.exit(0);
   }
-  p5.log.info(`Adding: ${toAdd.join(", ")}`);
-  const dlSpinner = p5.spinner();
+  p4.log.info(`Adding: ${toAdd.join(", ")}`);
+  const dlSpinner = p4.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p5.log.error(String(err));
+    p4.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
@@ -975,31 +876,10 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
     const vars = { projectName: name, components: allComponents, paths };
     const pkg = JSON.parse(await readFile5(join6(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    if (!hasBaseline(cwd)) {
-      const rebuildSpinner = p5.spinner();
-      rebuildSpinner.start("Establishing baseline");
-      await reconstructBaseline(
-        cwd,
-        repoDir,
-        existing,
-        existingPaths,
-        { projectName: name, components: existing, paths: existingPaths },
-        config.version || version
-      );
-      rebuildSpinner.stop("Baseline established.");
-    }
-    const spinner5 = p5.spinner();
-    spinner5.start("Adding to baseline");
-    await addToBaseline(cwd, repoDir, toAdd, allComponents, paths, vars, version);
-    spinner5.stop("Baseline updated.");
-    const result = mergeBaseline(cwd, `projx: add ${toAdd.join(", ")} from template v${version}`);
-    if (result.status === "conflicts") {
-      p5.log.warn(`Merge conflicts in ${result.conflictedFiles.length} file(s):`);
-      for (const f of result.conflictedFiles) {
-        p5.log.message(`  ${f}`);
-      }
-      p5.log.info("Resolve conflicts, then: git add . && git commit");
-    }
+    const spinner5 = p4.spinner();
+    spinner5.start("Adding components");
+    await writeTemplateToDir(cwd, repoDir, allComponents, paths, vars, version, "scaffold");
+    spinner5.stop("Components added.");
     if (!skipInstall) {
       await installDeps2(cwd, toAdd);
     }
@@ -1013,16 +893,16 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
         }
       }
     }
+    p4.outro(`Added ${toAdd.join(", ")}.
+
+  Like projx? Star it: https://github.com/ukanhaupa/projx`);
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p5.outro(`Added ${toAdd.join(", ")}.
-
-  Like projx? Star it: https://github.com/ukanhaupa/projx`);
 }
 async function installDeps2(dest, components) {
   for (const component of components) {
-    const spinner5 = p5.spinner();
+    const spinner5 = p4.spinner();
     try {
       switch (component) {
         case "fastapi":
@@ -1031,7 +911,7 @@ async function installDeps2(dest, components) {
             exec("uv sync --all-extras", join6(dest, "fastapi"));
             spinner5.stop("FastAPI dependencies installed.");
           } else {
-            p5.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
+            p4.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
@@ -1061,7 +941,7 @@ async function installDeps2(dest, components) {
             exec("flutter pub get", join6(dest, "mobile"));
             spinner5.stop("Flutter dependencies installed.");
           } else {
-            p5.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
+            p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
           break;
         case "infra":
@@ -1095,7 +975,7 @@ import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
 import { execSync as execSync4 } from "child_process";
 import { join as join8 } from "path";
-import * as p6 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 
 // src/detect.ts
 import { existsSync as existsSync6 } from "fs";
@@ -1183,21 +1063,21 @@ async function readPkg(dir) {
 
 // src/init.ts
 async function init(cwd, localRepo) {
-  p6.intro("projx init");
+  p5.intro("projx init");
   const isLocal = !!localRepo;
   if (existsSync7(join8(cwd, ".projx"))) {
-    p6.log.error("This project is already initialized. Use 'projx update' or 'projx add' instead.");
+    p5.log.error("This project is already initialized. Use 'npx create-projx update' or 'npx create-projx add' instead.");
     process.exit(1);
   }
   if (!isGitRepo2(cwd)) {
-    p6.log.error(`projx init requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
+    p5.log.error(`projx init requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
     process.exit(1);
   }
   if (hasUncommittedChanges2(cwd)) {
-    p6.log.error("You have uncommitted changes. Commit or stash them first.");
+    p5.log.error("You have uncommitted changes. Commit or stash them first.");
     process.exit(1);
   }
-  const spinner5 = p6.spinner();
+  const spinner5 = p5.spinner();
   spinner5.start("Scanning for components");
   const detected = await detectComponents(cwd);
   spinner5.stop(
@@ -1210,7 +1090,7 @@ async function init(cwd, localRepo) {
     confirmed = await manualSelect(cwd);
   }
   if (confirmed.length === 0) {
-    p6.log.warn("No components selected. Nothing to do.");
+    p5.log.warn("No components selected. Nothing to do.");
     process.exit(0);
   }
   const components = confirmed.map((c) => c.component);
@@ -1219,55 +1099,54 @@ async function init(cwd, localRepo) {
   );
   const projectName = toKebab(cwd.split("/").pop());
   const vars = { projectName, components, paths };
-  const dlSpinner = p6.spinner();
+  const dlSpinner = p5.spinner();
   dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
   const repoDir = await downloadRepo(localRepo).catch((err) => {
     dlSpinner.stop("Failed.");
-    p6.log.error(String(err));
+    p5.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
     const pkg = JSON.parse(await readFile6(join8(repoDir, "cli/package.json"), "utf-8"));
     const version = pkg.version;
-    const componentSkips = {};
-    for (const c of components) {
-      componentSkips[c] = ["**"];
-    }
-    const baselineSpinner = p6.spinner();
-    baselineSpinner.start("Creating template baseline");
-    await createBaseline(cwd, repoDir, components, paths, vars, version, "init", componentSkips);
-    baselineSpinner.stop("Baseline created.");
-    const mergeSpinner = p6.spinner();
-    mergeSpinner.start("Merging baseline (preserving your code)");
-    mergeBaseline(
-      cwd,
-      `projx: adopt template v${version} as baseline`,
-      true,
-      true
-    );
-    mergeSpinner.stop("Baseline merged. Your code is preserved.");
-    if (!existsSync7(join8(cwd, ".githooks"))) {
+    const applySpinner = p5.spinner();
+    applySpinner.start("Applying template");
+    const result = await applyTemplate(cwd, repoDir, components, paths, vars, version, "init");
+    applySpinner.stop("Template applied.");
+    if (existsSync7(join8(cwd, ".githooks"))) {
       try {
         execSync4("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
-        p6.log.success("Git hooks configured.");
       } catch {
-        p6.log.warn("Failed to configure git hooks.");
       }
     }
+    if (result.status === "conflicts") {
+      p5.log.warn("Some template files differ from your code. Changes written directly.");
+      p5.log.info("Review changes:");
+      p5.log.info("  git diff");
+      p5.log.info("");
+      p5.log.info("Keep a change:  git add <file>");
+      p5.log.info("Discard a change:  git checkout -- <file>");
+      p5.log.info('Commit when ready:  git add . && git commit -m "projx: init"');
+      p5.log.info("");
+      p5.log.info("To skip files on future updates, add to .projx-component:");
+      p5.log.info('  { "skip": ["src/**", "tests/**"] }');
+      p5.outro("Template applied. Review with git diff.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
+    } else {
+      p5.outro("Project initialized.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
+    }
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p6.outro("Project initialized. Run './setup.sh' to install dependencies.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
 }
 async function confirmDetections(detected) {
   const confirmed = [];
   for (const d of detected) {
-    const yes = await p6.confirm({
+    const yes = await p5.confirm({
       message: `Found ${LABELS[d.component].label} in ${d.directory}/ \u2014 register as "${d.component}"?`,
       initialValue: true
     });
-    if (p6.isCancel(yes)) process.exit(0);
+    if (p5.isCancel(yes)) process.exit(0);
     if (yes) {
       confirmed.push({ component: d.component, directory: d.directory });
     }
@@ -1275,7 +1154,7 @@ async function confirmDetections(detected) {
   return confirmed;
 }
 async function manualSelect(cwd) {
-  const selected = await p6.multiselect({
+  const selected = await p5.multiselect({
     message: "No components detected. Select manually:",
     options: COMPONENTS.map((c) => ({
       value: c,
@@ -1284,17 +1163,17 @@ async function manualSelect(cwd) {
     })),
     required: false
   });
-  if (p6.isCancel(selected)) process.exit(0);
+  if (p5.isCancel(selected)) process.exit(0);
   const result = [];
   for (const component of selected) {
-    const dir = await p6.text({
+    const dir = await p5.text({
       message: `Directory for ${LABELS[component].label}?`,
       placeholder: component,
       defaultValue: component
     });
-    if (p6.isCancel(dir)) process.exit(0);
+    if (p5.isCancel(dir)) process.exit(0);
     if (!existsSync7(join8(cwd, dir))) {
-      p6.log.warn(`${dir}/ does not exist \u2014 skipping.`);
+      p5.log.warn(`${dir}/ does not exist \u2014 skipping.`);
       continue;
     }
     result.push({ component, directory: dir });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-projx",
-  "version": "1.3.4",
+  "version": "1.3.5",
   "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": {