create-projx 1.1.2 → 1.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/utils.ts
@@ -185,14 +185,16 @@ async function readFileOrNull(path) {
     return null;
   }
 }
-async function writeComponentMarker(dir, component) {
+async function writeComponentMarker(dir, component, origin = "scaffold") {
   const markerPath = join(dir, COMPONENT_MARKER);
   let components = [component];
+  let existingOrigin = origin;
   const existing = await readFileOrNull(markerPath);
   if (existing) {
     try {
       const data = JSON.parse(existing);
       const prev = data.components ?? (data.component ? [data.component] : []);
+      existingOrigin = data.origin ?? origin;
       if (!prev.includes(component)) {
         components = [...prev, component];
       } else {
@@ -203,7 +205,7 @@ async function writeComponentMarker(dir, component) {
   }
   await writeFile(
     markerPath,
-    JSON.stringify({ components }, null, 2) + "\n"
+    JSON.stringify({ components, origin: existingOrigin }, null, 2) + "\n"
   );
 }
 async function discoverComponentPaths(cwd, components) {
@@ -265,8 +267,8 @@ function render(template, vars) {
       (_, expr) => {
         const parts = expr.split(".");
         let val = vars;
-        for (const p6 of parts) {
-          val = val?.[p6];
+        for (const p7 of parts) {
+          val = val?.[p7];
         }
         return String(val ?? "");
       }
@@ -317,9 +319,17 @@ async function runPrompts(nameArg) {
 }
 
 // src/scaffold.ts
-import { copyFileSync, existsSync as existsSync2 } from "fs";
-import { chmod, mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+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";
+
+// src/baseline.ts
+import { existsSync as existsSync2 } from "fs";
+import { chmod, mkdir as mkdir2, writeFile as writeFile2, rm as rm2 } from "fs/promises";
+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
@@ -381,42 +391,70 @@ function generateVscodeSettings(vars) {
   return JSON.stringify(settings, null, 2) + "\n";
 }
 
-// src/scaffold.ts
-async function scaffold(opts, dest, localRepo) {
-  const name = toKebab(opts.name);
-  const nameSnake = toSnake(opts.name);
-  const paths = Object.fromEntries(
-    opts.components.map((c) => [c, c])
-  );
-  const vars = { projectName: name, components: opts.components, paths };
-  const isLocal = !!localRepo;
-  await mkdir2(dest, { recursive: true });
-  const dlSpinner = p2.spinner();
-  dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
-  const repoDir = await downloadRepo(localRepo).catch((err) => {
-    dlSpinner.stop("Failed.");
-    p2.log.error(String(err));
-    process.exit(1);
-  });
-  dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
+// src/baseline.ts
+var BASELINE_BRANCH = "projx/baseline";
+function hasBaseline(cwd) {
   try {
-    await doScaffold(opts, dest, repoDir, name, nameSnake, vars);
-  } finally {
-    await cleanupRepo(repoDir, isLocal);
+    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 {
+    }
   }
 }
-async function doScaffold(opts, dest, repoDir, name, nameSnake, vars) {
-  p2.log.info(`Scaffolding project in ${dest}`);
-  for (const component of opts.components) {
-    const spinner5 = p2.spinner();
-    spinner5.start(`Copying ${component}/`);
-    await copyComponent(repoDir, component, dest);
-    await writeComponentMarker(join3(dest, component), component);
-    spinner5.stop(`${component}/`);
-  }
-  await substituteNames(dest, opts.components, name, nameSnake);
-  const hasBackend = opts.components.includes("fastapi") || opts.components.includes("fastify");
-  if (hasBackend || opts.components.includes("frontend")) {
+async function writeTemplateToDir(dest, repoDir, components, componentPaths, vars, version, origin) {
+  const name = vars.projectName;
+  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 });
+    }
+    await writeComponentMarker(join3(dest, targetDir), component, origin);
+  }
+  await substituteNames(dest, components, componentPaths, name, nameSnake);
+  const hasBackend = components.includes("fastapi") || components.includes("fastify");
+  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));
   }
@@ -431,131 +469,225 @@ async function doScaffold(opts, dest, repoDir, name, nameSnake, vars) {
   await copyStaticFiles(repoDir, dest);
   await mkdir2(join3(dest, ".vscode"), { recursive: true });
   await writeFile2(join3(dest, ".vscode/settings.json"), generateVscodeSettings(vars));
-  const pkg = JSON.parse(
-    await readFile3(join3(repoDir, "cli/package.json"), "utf-8")
-  );
   const projxConfig = {
-    version: pkg.version,
-    components: opts.components,
+    version,
+    components,
     createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-    paths: vars.paths
-  };
-  await writeFile2(join3(dest, ".projx"), JSON.stringify(projxConfig, null, 2));
-  if (opts.git) {
-    try {
-      exec("git init", dest);
-      exec("git config core.hooksPath .githooks", dest);
-      p2.log.success("Git initialized with hooks.");
-    } catch {
-      p2.log.warn("Failed to initialize git.");
-    }
-  }
-  if (opts.install) {
-    await installDeps(dest, opts.components);
-  }
-  copyEnvExamples(dest, opts.components);
-  if (opts.git) {
-    try {
-      exec("git add -A", dest);
-      exec('git commit -m "Initial scaffold from projx"', dest);
-      p2.log.success("Initial commit created.");
-    } catch {
+    baseline: {
+      branch: BASELINE_BRANCH,
+      templateVersion: version
     }
-  }
-  p2.outro(`Done! Next steps:
-
-  cd ${name}
-  ./setup.sh
-
-  Like projx? Star it: https://github.com/ukanhaupa/projx`);
+  };
+  await writeFile2(join3(dest, ".projx"), JSON.stringify(projxConfig, null, 2) + "\n");
 }
-async function substituteNames(dest, components, name, nameSnake) {
+async function substituteNames(dest, components, paths, name, nameSnake) {
   if (components.includes("fastapi")) {
-    await replaceInFile(
-      join3(dest, "fastapi/pyproject.toml"),
-      "projx-fastapi",
-      `${name}-fastapi`
-    );
+    await replaceInFile(join3(dest, `${paths.fastapi}/pyproject.toml`), "projx-fastapi", `${name}-fastapi`);
   }
   if (components.includes("fastify")) {
-    await replaceInFile(
-      join3(dest, "fastify/package.json"),
-      "projx-fastify",
-      `${name}-fastify`
-    );
+    await replaceInFile(join3(dest, `${paths.fastify}/package.json`), "projx-fastify", `${name}-fastify`);
   }
   if (components.includes("frontend")) {
-    await replaceInFile(
-      join3(dest, "frontend/package.json"),
-      "projx-frontend",
-      `${name}-frontend`
-    );
+    await replaceInFile(join3(dest, `${paths.frontend}/package.json`), "projx-frontend", `${name}-frontend`);
   }
   if (components.includes("e2e")) {
-    await replaceInFile(
-      join3(dest, "e2e/package.json"),
-      "projx-e2e",
-      `${name}-e2e`
-    );
+    await replaceInFile(join3(dest, `${paths.e2e}/package.json`), "projx-e2e", `${name}-e2e`);
   }
   if (components.includes("mobile")) {
-    await replaceInFile(
-      join3(dest, "mobile/pubspec.yaml"),
-      "projx_mobile",
-      `${nameSnake}_mobile`
+    await replaceInFile(join3(dest, `${paths.mobile}/pubspec.yaml`), "projx_mobile", `${nameSnake}_mobile`);
+    await replaceInDir(join3(dest, `${paths.mobile}`), "package:projx_mobile/", `package:${nameSnake}_mobile/`, ".dart");
+  }
+}
+async function createBaseline(cwd, repoDir, components, componentPaths, vars, version, origin = "scaffold") {
+  const worktree = createWorktree(cwd, BASELINE_BRANCH, true);
+  try {
+    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, origin);
+    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" }
     );
-    await replaceInDir(
-      join3(dest, "mobile"),
-      "package:projx_mobile/",
-      `package:${nameSnake}_mobile/`,
-      ".dart"
+  } finally {
+    removeWorktree(cwd, worktree);
+  }
+}
+async function updateBaseline(cwd, repoDir, components, componentPaths, vars, version) {
+  const worktree = createWorktree(cwd, BASELINE_BRANCH, false);
+  try {
+    execSync2("git rm -rf .", { cwd: worktree, stdio: "pipe" });
+    await writeTemplateToDir(worktree, repoDir, components, componentPaths, vars, version, "scaffold");
+    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 };
+    }
+    execSync2(
+      `git commit --no-verify -m "projx: update baseline to template v${version}"`,
+      { 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" });
+    } 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) {
+      return { status: "clean" };
+    }
+    return {
+      status: "conflicts",
+      conflictedFiles: conflicted.split("\n").filter(Boolean)
+    };
+  }
+}
+async function reconstructBaseline(cwd, repoDir, components, componentPaths, vars, version) {
+  p2.log.warn("projx/baseline branch not found. Reconstructing...");
+  await createBaseline(cwd, repoDir, components, componentPaths, vars, version);
+  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) {
+  const name = toKebab(opts.name);
+  const paths = Object.fromEntries(
+    opts.components.map((c) => [c, c])
+  );
+  const vars = { projectName: name, components: opts.components, paths };
+  const isLocal = !!localRepo;
+  await mkdir3(dest, { recursive: true });
+  const dlSpinner = p3.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));
+    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}`);
+    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.");
+    }
+    if (opts.install) {
+      await installDeps(dest, opts.components);
+    }
+    copyEnvExamples(dest, opts.components);
+    if (opts.git) {
+      try {
+        exec("git add -A", dest);
+        exec('git commit --no-verify -m "Initial scaffold from projx"', dest);
+      } catch {
+      }
+    }
+  } finally {
+    await cleanupRepo(repoDir, isLocal);
+  }
+  p3.outro(`Done! Next steps:
+
+  cd ${name}
+  ./setup.sh
+
+  Like projx? Star it: https://github.com/ukanhaupa/projx`);
 }
 async function installDeps(dest, components) {
   for (const component of components) {
-    const spinner5 = p2.spinner();
+    const spinner5 = p3.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
             spinner5.start("Installing FastAPI dependencies (uv sync)");
-            exec("uv sync --all-extras", join3(dest, "fastapi"));
+            exec("uv sync --all-extras", join4(dest, "fastapi"));
             spinner5.stop("FastAPI dependencies installed.");
           } else {
-            p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
+            p3.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand("pnpm")) {
             spinner5.start("Installing Fastify dependencies (pnpm install)");
-            exec("pnpm install", join3(dest, "fastify"));
+            exec("pnpm install", join4(dest, "fastify"));
             spinner5.stop("Fastify dependencies installed.");
           } else {
             spinner5.start("Installing Fastify dependencies (npm install)");
-            exec("npm install", join3(dest, "fastify"));
+            exec("npm install", join4(dest, "fastify"));
             spinner5.stop("Fastify dependencies installed.");
           }
           break;
         case "frontend":
           spinner5.start("Installing Frontend dependencies (npm install)");
-          exec("npm install", join3(dest, "frontend"));
+          exec("npm install", join4(dest, "frontend"));
           spinner5.stop("Frontend dependencies installed.");
           break;
         case "e2e":
           spinner5.start("Installing E2E dependencies (npm install)");
-          exec("npm install", join3(dest, "e2e"));
+          exec("npm install", join4(dest, "e2e"));
           spinner5.stop("E2E dependencies installed.");
           break;
         case "mobile":
           if (hasCommand("flutter")) {
             spinner5.start("Installing Flutter dependencies");
-            exec("flutter pub get", join3(dest, "mobile"));
+            exec("flutter pub get", join4(dest, "mobile"));
             spinner5.stop("Flutter dependencies installed.");
           } else {
-            p2.log.warn(
-              "Flutter not found \u2014 run 'cd mobile && flutter pub get' manually."
-            );
+            p3.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
           break;
         case "infra":
@@ -568,9 +700,9 @@ async function installDeps(dest, components) {
 }
 function copyEnvExamples(dest, components) {
   for (const component of components) {
-    const example = join3(dest, component, ".env.example");
-    const env = join3(dest, component, ".env");
-    if (existsSync2(example) && !existsSync2(env)) {
+    const example = join4(dest, component, ".env.example");
+    const env = join4(dest, component, ".env");
+    if (existsSync3(example) && !existsSync3(env)) {
       try {
         copyFileSync(example, env);
       } catch {
@@ -580,66 +712,32 @@ function copyEnvExamples(dest, components) {
 }
 
 // src/update.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3, chmod as chmod2, cp as cp2, rm as rm2 } from "fs/promises";
-import { execSync as execSync2 } from "child_process";
-import { join as join4 } from "path";
-import * as p3 from "@clack/prompts";
-var NEVER_OVERWRITE = [
-  /\.env$/,
-  /\.env\.(dev|staging|prod)$/,
-  /prisma\/migrations\//,
-  /src\/migrations\/versions\//,
-  /\.projx-component$/
-];
-var MERGE_DEPS = [
-  /^[^/]+\/package\.json$/,
-  /^[^/]+\/pyproject\.toml$/
-];
-function isGitRepo(cwd) {
-  try {
-    execSync2("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasUncommittedChanges(cwd) {
-  try {
-    const status = execSync2("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
-    return status.length > 0;
-  } catch {
-    return false;
-  }
-}
-function branchExists(cwd, branch) {
-  try {
-    execSync2(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd, stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getCurrentBranch(cwd) {
-  return execSync2("git branch --show-current", { cwd, stdio: "pipe" }).toString().trim();
-}
+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";
 async function update(cwd, localRepo) {
-  p3.intro("projx update");
+  p4.intro("projx update");
   const isLocal = !!localRepo;
-  const configPath = join4(cwd, ".projx");
+  if (!isGitRepo(cwd)) {
+    p4.log.error(`projx update requires a git repo. Run 'git init && git add -A && git commit -m "initial"' first.`);
+    process.exit(1);
+  }
+  if (hasUncommittedChanges(cwd)) {
+    p4.log.error("You have uncommitted changes. Commit or stash them first.");
+    process.exit(1);
+  }
+  const configPath = join5(cwd, ".projx");
   let config;
-  if (existsSync3(configPath)) {
+  if (existsSync4(configPath)) {
     config = JSON.parse(await readFile4(configPath, "utf-8"));
-    p3.log.info(
-      `Found .projx (v${config.version}, components: ${config.components.join(", ")})`
-    );
+    p4.log.info(`Found .projx (v${config.version}, components: ${config.components.join(", ")})`);
   } else {
-    p3.log.warn("No .projx file found. Detecting components from directories.");
-    const detected = COMPONENTS.filter(
-      (c) => existsSync3(join4(cwd, c))
-    );
+    p4.log.warn("No .projx file found. Detecting components from directories.");
+    const detected = COMPONENTS.filter((c) => existsSync4(join5(cwd, c)));
     if (detected.length === 0) {
-      p3.log.error("No projx components found in this directory.");
+      p4.log.error("No projx components found. Run 'projx init' first.");
       process.exit(1);
     }
     config = {
@@ -647,180 +745,93 @@ async function update(cwd, localRepo) {
       components: detected,
       createdAt: "unknown"
     };
-    p3.log.info(`Detected: ${detected.join(", ")}`);
+    p4.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) {
-      p3.log.info(`${c} \u2192 ${componentPaths[c]}/`);
+      p4.log.info(`${c} \u2192 ${componentPaths[c]}/`);
     }
   }
-  const useGitBranch = isGitRepo(cwd);
-  let branchName;
-  let originalBranch;
-  if (useGitBranch) {
-    if (hasUncommittedChanges(cwd)) {
-      p3.log.error("You have uncommitted changes. Commit or stash them first.");
-      process.exit(1);
-    }
-    originalBranch = getCurrentBranch(cwd);
-    const dlSpinner = p3.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));
-      process.exit(1);
-    });
-    dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
-    const pkg = JSON.parse(
-      await readFile4(join4(repoDir, "cli/package.json"), "utf-8")
-    );
-    branchName = `projx/update-v${pkg.version}`;
-    if (branchExists(cwd, branchName)) {
-      let suffix = 1;
-      while (branchExists(cwd, `${branchName}-${suffix}`)) suffix++;
-      branchName = `${branchName}-${suffix}`;
+  const dlSpinner = p4.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));
+    process.exit(1);
+  });
+  dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
+  try {
+    const pkg = JSON.parse(await readFile4(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 };
+    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);
+      rebuildSpinner.stop("Baseline established.");
     }
-    execSync2(`git checkout -b ${branchName}`, { cwd, stdio: "pipe" });
-    p3.log.info(`Created branch: ${branchName}`);
-    let touchedFiles;
-    try {
-      touchedFiles = await doUpdate(cwd, config, repoDir, pkg.version, componentPaths);
-    } finally {
-      await cleanupRepo(repoDir, isLocal);
+    const updateSpinner = p4.spinner();
+    updateSpinner.start("Updating baseline to latest template");
+    const { changed } = await updateBaseline(cwd, repoDir, config.components, componentPaths, vars, version);
+    if (!changed) {
+      updateSpinner.stop("Already up to date.");
+      p4.outro("No template changes to apply.");
+      return;
     }
-    for (const f of touchedFiles) {
-      execSync2(`git add "${f}"`, { cwd, stdio: "pipe" });
+    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 === "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"
+      );
+    } else {
+      p4.outro(`Updated to template v${version}. All changes merged cleanly.`);
     }
-    execSync2(`git commit --no-verify -m "projx update to v${pkg.version}"`, { cwd, stdio: "pipe" });
-    p3.outro(
-      `Updated on branch: ${branchName}
-
-  Review changes:
-    git diff ${originalBranch}...${branchName}
-
-  Switch back and merge:
-    git checkout ${originalBranch} && git merge ${branchName}`
-    );
-  } else {
-    const dlSpinner = p3.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));
-      process.exit(1);
-    });
-    dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
-    const pkg = JSON.parse(
-      await readFile4(join4(repoDir, "cli/package.json"), "utf-8")
-    );
+  } catch (err) {
     try {
-      await doUpdate(cwd, config, repoDir, pkg.version, componentPaths);
-    } finally {
-      await cleanupRepo(repoDir, isLocal);
+      execSync3("git merge --abort", { cwd, stdio: "pipe" });
+    } catch {
     }
-    p3.outro(`Updated to v${pkg.version}. Review changes before committing.`);
+    p4.log.error(`Update failed: ${err}`);
+    p4.log.info("Your code is safe. Run 'git merge --abort' if needed.");
+    process.exit(1);
+  } finally {
+    await cleanupRepo(repoDir, isLocal);
   }
 }
-async function doUpdate(cwd, config, repoDir, version, componentPaths) {
-  const name = detectProjectName(cwd, config.components, componentPaths);
-  const nameSnake = toSnake(name);
-  const vars = { projectName: name, components: config.components, paths: componentPaths };
-  const touchedFiles = [];
-  const usedPaths = /* @__PURE__ */ new Set();
-  for (const component of config.components) {
-    const targetDir = componentPaths[component];
-    if (usedPaths.has(targetDir)) {
-      p3.log.warn(`${component} shares directory ${targetDir}/ with another component \u2014 skipping overlay to avoid nesting.`);
-      continue;
-    }
-    usedPaths.add(targetDir);
-    const spinner6 = p3.spinner();
-    spinner6.start(`Updating ${targetDir}/ (${component})`);
-    const componentSrc = join4(repoDir, component);
-    if (!existsSync3(componentSrc)) {
-      spinner6.stop(`${component} template not found, skipping.`);
-      continue;
-    }
-    const tmpDest = join4(cwd, `.projx-tmp`);
-    const files = await copyComponent(repoDir, component, tmpDest);
-    for (const file of files) {
-      const src = join4(tmpDest, component, file);
-      const destRel = `${targetDir}/${file}`;
-      const dest = join4(cwd, destRel);
-      if (NEVER_OVERWRITE.some((re) => re.test(destRel))) continue;
-      const dir = dest.substring(0, dest.lastIndexOf("/"));
-      await mkdir3(dir, { recursive: true });
-      if (MERGE_DEPS.some((re) => re.test(destRel)) && existsSync3(dest)) {
-        const merged = await mergeDeps(dest, src);
-        if (merged) {
-          await writeFile3(dest, merged);
-          touchedFiles.push(destRel);
-        }
-      } else {
-        await cp2(src, dest, { force: true });
-        touchedFiles.push(destRel);
-      }
-    }
-    await rm2(tmpDest, { recursive: true, force: true });
-    if (!existsSync3(join4(cwd, targetDir, ".projx-component"))) {
-      await writeComponentMarker(join4(cwd, targetDir), component);
-      touchedFiles.push(`${targetDir}/.projx-component`);
-    }
-    spinner6.stop(`${targetDir}/ updated.`);
-  }
-  const spinner5 = p3.spinner();
-  spinner5.start("Updating shared files");
-  const hasBackend = config.components.includes("fastapi") || config.components.includes("fastify");
-  if (hasBackend || config.components.includes("frontend")) {
-    await writeFile3(join4(cwd, "docker-compose.yml"), await generateDockerCompose(vars));
-    touchedFiles.push("docker-compose.yml");
-    await writeFile3(join4(cwd, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
-    touchedFiles.push("docker-compose.dev.yml");
-  }
-  await mkdir3(join4(cwd, ".githooks"), { recursive: true });
-  await writeFile3(join4(cwd, ".githooks/pre-commit"), await generatePreCommit(vars));
-  await chmod2(join4(cwd, ".githooks/pre-commit"), 493);
-  touchedFiles.push(".githooks/pre-commit");
-  await mkdir3(join4(cwd, ".github/workflows"), { recursive: true });
-  await writeFile3(join4(cwd, ".github/workflows/ci.yml"), await generateCiYml(vars));
-  touchedFiles.push(".github/workflows/ci.yml");
-  await writeFile3(join4(cwd, "setup.sh"), await generateSetupSh(vars));
-  await chmod2(join4(cwd, "setup.sh"), 493);
-  touchedFiles.push("setup.sh");
-  await mkdir3(join4(cwd, ".vscode"), { recursive: true });
-  await writeFile3(join4(cwd, ".vscode/settings.json"), generateVscodeSettings(vars));
-  touchedFiles.push(".vscode/settings.json");
-  spinner5.stop("Shared files updated.");
-  if (config.components.includes("mobile")) {
-    const mobilePath = componentPaths.mobile ?? "mobile";
-    await replaceInDir(
-      join4(cwd, mobilePath),
-      "package:projx_mobile/",
-      `package:${nameSnake}_mobile/`,
-      ".dart"
-    );
+function isGitRepo(cwd) {
+  try {
+    execSync3("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasUncommittedChanges(cwd) {
+  try {
+    const status = execSync3("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+    return status.length > 0;
+  } catch {
+    return false;
   }
-  const updatedConfig = {
-    version,
-    components: config.components,
-    createdAt: config.createdAt,
-    paths: componentPaths
-  };
-  await writeFile3(join4(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2));
-  touchedFiles.push(".projx");
-  return touchedFiles;
 }
 function detectProjectName(cwd, components, componentPaths) {
   for (const component of components) {
     const dir = componentPaths[component] ?? component;
-    const pkgPath = join4(cwd, dir, "package.json");
-    if (existsSync3(pkgPath)) {
+    const pkgPath = join5(cwd, dir, "package.json");
+    if (existsSync4(pkgPath)) {
       try {
-        const pkg = JSON.parse(
-          readFileSync(pkgPath, "utf-8")
-        );
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         const n = pkg.name;
         if (n && n.includes("-")) {
           return n.substring(0, n.lastIndexOf("-"));
@@ -831,247 +842,136 @@ function detectProjectName(cwd, components, componentPaths) {
   }
   return toKebab(cwd.split("/").pop());
 }
-async function mergeDeps(existingPath, templatePath) {
-  if (existingPath.endsWith("package.json")) {
-    return mergePackageJson(existingPath, templatePath);
-  }
-  if (existingPath.endsWith("pyproject.toml")) {
-    return mergePyprojectToml(existingPath, templatePath);
-  }
-  return null;
-}
-async function mergePackageJson(existingPath, templatePath) {
-  const existingRaw = await readFileOrNull(existingPath);
-  const templateRaw = await readFileOrNull(templatePath);
-  if (!existingRaw || !templateRaw) return null;
-  try {
-    const existing = JSON.parse(existingRaw);
-    const template = JSON.parse(templateRaw);
-    if (template.dependencies) {
-      existing.dependencies = { ...template.dependencies, ...existing.dependencies };
-    }
-    if (template.devDependencies) {
-      existing.devDependencies = { ...template.devDependencies, ...existing.devDependencies };
-    }
-    if (template.scripts) {
-      existing.scripts = { ...template.scripts, ...existing.scripts };
-    }
-    return JSON.stringify(existing, null, 2) + "\n";
-  } catch {
-    return null;
-  }
-}
-async function mergePyprojectToml(existingPath, templatePath) {
-  const existingRaw = await readFileOrNull(existingPath);
-  const templateRaw = await readFileOrNull(templatePath);
-  if (!existingRaw || !templateRaw) return null;
-  const templateDeps = extractTomlDeps(templateRaw);
-  if (templateDeps.length === 0) return null;
-  const existingDeps = extractTomlDeps(existingRaw);
-  const existingNames = new Set(existingDeps.map((d) => d.replace(/[><=!~[].*/, "").trim().toLowerCase()));
-  const newDeps = templateDeps.filter((d) => {
-    const name = d.replace(/[><=!~[].*/, "").trim().toLowerCase();
-    return !existingNames.has(name);
-  });
-  if (newDeps.length === 0) return null;
-  const depsMatch = existingRaw.match(/^dependencies\s*=\s*\[([^\]]*)\]/m);
-  if (!depsMatch) return null;
-  const closingBracket = existingRaw.indexOf("]", depsMatch.index);
-  const before = existingRaw.slice(0, closingBracket);
-  const after = existingRaw.slice(closingBracket);
-  const indent = "  ";
-  const newLines = newDeps.map((d) => `${indent}"${d}",`).join("\n");
-  return before.trimEnd() + "\n" + newLines + "\n" + after;
-}
-function extractTomlDeps(toml) {
-  const match = toml.match(/^dependencies\s*=\s*\[([\s\S]*?)\]/m);
-  if (!match) return [];
-  return match[1].split("\n").map((l) => l.trim()).filter((l) => l.startsWith('"') || l.startsWith("'")).map((l) => l.replace(/^["']|["'],?$/g, "").trim()).filter(Boolean);
-}
 
 // src/add.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-import { chmod as chmod3, mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
-import * as p4 from "@clack/prompts";
+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";
 async function add(cwd, newComponents, localRepo, skipInstall = false) {
-  p4.intro("projx add");
+  p5.intro("projx add");
   const isLocal = !!localRepo;
-  const configPath = join5(cwd, ".projx");
-  if (!existsSync4(configPath)) {
-    p4.log.error("No .projx file found. Run 'projx <name>' to create a project first.");
+  const configPath = join6(cwd, ".projx");
+  if (!existsSync5(configPath)) {
+    p5.log.error("No .projx file found. Run '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) {
-    p4.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
+    p5.log.warn(`Already present: ${alreadyExists.join(", ")}. Skipping those.`);
   }
   const toAdd = newComponents.filter((c) => !existing.includes(c));
   if (toAdd.length === 0) {
-    p4.log.info("Nothing new to add.");
+    p5.log.info("Nothing new to add.");
     process.exit(0);
   }
-  p4.log.info(`Adding: ${toAdd.join(", ")}`);
-  const dlSpinner = p4.spinner();
+  p5.log.info(`Adding: ${toAdd.join(", ")}`);
+  const dlSpinner = p5.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));
+    p5.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    await doAdd(cwd, config, toAdd, repoDir, skipInstall);
-  } finally {
-    await cleanupRepo(repoDir, isLocal);
-  }
-}
-async function doAdd(cwd, config, toAdd, repoDir, skipInstall) {
-  const allComponents = [...config.components, ...toAdd];
-  const existingPaths = await discoverComponentPaths(cwd, config.components);
-  const paths = { ...existingPaths };
-  for (const c of toAdd) paths[c] = c;
-  const name = detectProjectName2(cwd, config.components, paths);
-  const nameSnake = toSnake(name);
-  const vars = { projectName: name, components: allComponents, paths };
-  for (const component of toAdd) {
-    const spinner6 = p4.spinner();
-    spinner6.start(`Adding ${component}/`);
-    await copyComponent(repoDir, component, cwd);
-    await writeComponentMarker(join5(cwd, component), component);
-    spinner6.stop(`${component}/`);
-  }
-  await substituteNames2(cwd, toAdd, name, nameSnake);
-  const spinner5 = p4.spinner();
-  spinner5.start("Regenerating shared files");
-  const hasBackend = allComponents.includes("fastapi") || allComponents.includes("fastify");
-  if (hasBackend || allComponents.includes("frontend")) {
-    await writeFile4(join5(cwd, "docker-compose.yml"), await generateDockerCompose(vars));
-    await writeFile4(join5(cwd, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
-  }
-  await writeFile4(join5(cwd, "README.md"), await generateReadme(vars));
-  await mkdir4(join5(cwd, ".githooks"), { recursive: true });
-  await writeFile4(join5(cwd, ".githooks/pre-commit"), await generatePreCommit(vars));
-  await chmod3(join5(cwd, ".githooks/pre-commit"), 493);
-  await mkdir4(join5(cwd, ".github/workflows"), { recursive: true });
-  await writeFile4(join5(cwd, ".github/workflows/ci.yml"), await generateCiYml(vars));
-  await writeFile4(join5(cwd, "setup.sh"), await generateSetupSh(vars));
-  await chmod3(join5(cwd, "setup.sh"), 493);
-  spinner5.stop("Shared files regenerated.");
-  if (!skipInstall) {
-    await installDeps2(cwd, toAdd);
-  }
-  for (const component of toAdd) {
-    const example = join5(cwd, component, ".env.example");
-    const env = join5(cwd, component, ".env");
-    if (existsSync4(example) && !existsSync4(env)) {
-      try {
-        copyFileSync2(example, env);
-      } catch {
+    const allComponents = [...existing, ...toAdd];
+    const existingPaths = await discoverComponentPaths(cwd, existing);
+    const paths = { ...existingPaths };
+    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 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");
+    }
+    if (!skipInstall) {
+      await installDeps2(cwd, toAdd);
+    }
+    for (const component of toAdd) {
+      const example = join6(cwd, component, ".env.example");
+      const env = join6(cwd, component, ".env");
+      if (existsSync5(example) && !existsSync5(env)) {
+        try {
+          copyFileSync2(example, env);
+        } catch {
+        }
       }
     }
+  } finally {
+    await cleanupRepo(repoDir, isLocal);
   }
-  const pkg = JSON.parse(
-    await readFile5(join5(repoDir, "cli/package.json"), "utf-8")
-  );
-  const updatedConfig = {
-    version: pkg.version,
-    components: allComponents,
-    createdAt: config.createdAt,
-    paths
-  };
-  await writeFile4(join5(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2));
-  p4.outro(`Added ${toAdd.join(", ")}. Shared files updated for all ${allComponents.length} components.
+  p5.outro(`Added ${toAdd.join(", ")}.
 
   Like projx? Star it: https://github.com/ukanhaupa/projx`);
 }
-async function substituteNames2(dest, components, name, nameSnake) {
-  if (components.includes("fastapi")) {
-    await replaceInFile(
-      join5(dest, "fastapi/pyproject.toml"),
-      "projx-fastapi",
-      `${name}-fastapi`
-    );
-  }
-  if (components.includes("fastify")) {
-    await replaceInFile(
-      join5(dest, "fastify/package.json"),
-      "projx-fastify",
-      `${name}-fastify`
-    );
-  }
-  if (components.includes("frontend")) {
-    await replaceInFile(
-      join5(dest, "frontend/package.json"),
-      "projx-frontend",
-      `${name}-frontend`
-    );
-  }
-  if (components.includes("e2e")) {
-    await replaceInFile(
-      join5(dest, "e2e/package.json"),
-      "projx-e2e",
-      `${name}-e2e`
-    );
-  }
-  if (components.includes("mobile")) {
-    await replaceInFile(
-      join5(dest, "mobile/pubspec.yaml"),
-      "projx_mobile",
-      `${nameSnake}_mobile`
-    );
-    await replaceInDir(
-      join5(dest, "mobile"),
-      "package:projx_mobile/",
-      `package:${nameSnake}_mobile/`,
-      ".dart"
-    );
-  }
-}
 async function installDeps2(dest, components) {
   for (const component of components) {
-    const spinner5 = p4.spinner();
+    const spinner5 = p5.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
             spinner5.start("Installing FastAPI dependencies");
-            exec("uv sync --all-extras", join5(dest, "fastapi"));
+            exec("uv sync --all-extras", join6(dest, "fastapi"));
             spinner5.stop("FastAPI dependencies installed.");
           } else {
-            p4.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
+            p5.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand("pnpm")) {
             spinner5.start("Installing Fastify dependencies");
-            exec("pnpm install", join5(dest, "fastify"));
+            exec("pnpm install", join6(dest, "fastify"));
             spinner5.stop("Fastify dependencies installed.");
           } else {
             spinner5.start("Installing Fastify dependencies");
-            exec("npm install", join5(dest, "fastify"));
+            exec("npm install", join6(dest, "fastify"));
             spinner5.stop("Fastify dependencies installed.");
           }
           break;
         case "frontend":
           spinner5.start("Installing Frontend dependencies");
-          exec("npm install", join5(dest, "frontend"));
+          exec("npm install", join6(dest, "frontend"));
           spinner5.stop("Frontend dependencies installed.");
           break;
         case "e2e":
           spinner5.start("Installing E2E dependencies");
-          exec("npm install", join5(dest, "e2e"));
+          exec("npm install", join6(dest, "e2e"));
           spinner5.stop("E2E dependencies installed.");
           break;
         case "mobile":
           if (hasCommand("flutter")) {
             spinner5.start("Installing Flutter dependencies");
-            exec("flutter pub get", join5(dest, "mobile"));
+            exec("flutter pub get", join6(dest, "mobile"));
             spinner5.stop("Flutter dependencies installed.");
           } else {
-            p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
+            p5.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
           break;
         case "infra":
@@ -1085,12 +985,10 @@ async function installDeps2(dest, components) {
 function detectProjectName2(cwd, components, paths) {
   for (const component of components) {
     const dir = paths[component] ?? component;
-    const pkgPath = join5(cwd, dir, "package.json");
-    if (existsSync4(pkgPath)) {
+    const pkgPath = join6(cwd, dir, "package.json");
+    if (existsSync5(pkgPath)) {
       try {
-        const pkg = JSON.parse(
-          readFileSync2(pkgPath, "utf-8")
-        );
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
         const n = pkg.name;
         if (n && n.includes("-")) {
           return n.substring(0, n.lastIndexOf("-"));
@@ -1103,22 +1001,22 @@ function detectProjectName2(cwd, components, paths) {
 }
 
 // src/init.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5, chmod as chmod4, cp as cp3 } from "fs/promises";
-import { execSync as execSync3 } from "child_process";
-import { join as join7 } from "path";
-import * as p5 from "@clack/prompts";
+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";
 
 // src/detect.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir as readdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function detectComponents(cwd) {
   const results = [];
   const entries = await readdir2(cwd, { withFileTypes: true });
   const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !EXCLUDE.has(e.name)).map((e) => e.name);
   for (const dir of dirs) {
-    const full = join6(cwd, dir);
+    const full = join7(cwd, dir);
     const detections = await scanDirectory(full, dir);
     results.push(...detections);
   }
@@ -1126,7 +1024,7 @@ async function detectComponents(cwd) {
 }
 async function scanDirectory(dir, relPath) {
   const results = [];
-  const pyproject = await readFileOrNull(join6(dir, "pyproject.toml"));
+  const pyproject = await readFileOrNull(join7(dir, "pyproject.toml"));
   if (pyproject && /fastapi/i.test(pyproject)) {
     results.push({
       component: "fastapi",
@@ -1163,7 +1061,7 @@ async function scanDirectory(dir, relPath) {
       });
     }
   }
-  const pubspec = await readFileOrNull(join6(dir, "pubspec.yaml"));
+  const pubspec = await readFileOrNull(join7(dir, "pubspec.yaml"));
   if (pubspec && /flutter:/i.test(pubspec)) {
     results.push({
       component: "mobile",
@@ -1172,7 +1070,7 @@ async function scanDirectory(dir, relPath) {
       evidence: "pubspec.yaml has flutter dependency"
     });
   }
-  const hasTf = existsSync5(join6(dir, "main.tf")) || existsSync5(join6(dir, "variables.tf")) || existsSync5(join6(dir, "stack/main.tf")) || existsSync5(join6(dir, "versions.tf"));
+  const hasTf = existsSync6(join7(dir, "main.tf")) || existsSync6(join7(dir, "variables.tf")) || existsSync6(join7(dir, "stack/main.tf")) || existsSync6(join7(dir, "versions.tf"));
   if (hasTf) {
     results.push({
       component: "infra",
@@ -1184,7 +1082,7 @@ async function scanDirectory(dir, relPath) {
   return results;
 }
 async function readPkg(dir) {
-  const content = await readFileOrNull(join6(dir, "package.json"));
+  const content = await readFileOrNull(join7(dir, "package.json"));
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -1193,83 +1091,23 @@ async function readPkg(dir) {
   }
 }
 
-// src/diff.ts
-function unifiedDiff(existing, template, label) {
-  const a = existing.split("\n");
-  const b = template.split("\n");
-  const lines = [`--- existing ${label}`, `+++ template ${label}`];
-  const lcs = computeLCS(a, b);
-  let ai = 0;
-  let bi = 0;
-  for (const match of lcs) {
-    while (ai < match.ai) lines.push(`\x1B[31m- ${a[ai++]}\x1B[0m`);
-    while (bi < match.bi) lines.push(`\x1B[32m+ ${b[bi++]}\x1B[0m`);
-    lines.push(`  ${a[ai]}`);
-    ai++;
-    bi++;
-  }
-  while (ai < a.length) lines.push(`\x1B[31m- ${a[ai++]}\x1B[0m`);
-  while (bi < b.length) lines.push(`\x1B[32m+ ${b[bi++]}\x1B[0m`);
-  if (lines.length > 80) {
-    return lines.slice(0, 80).join("\n") + `
-... (${lines.length - 80} more lines)`;
-  }
-  return lines.join("\n");
-}
-function computeLCS(a, b) {
-  const m = a.length;
-  const n = b.length;
-  if (m * n > 1e5) {
-    return simpleLCS(a, b);
-  }
-  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-  for (let i2 = m - 1; i2 >= 0; i2--) {
-    for (let j2 = n - 1; j2 >= 0; j2--) {
-      if (a[i2] === b[j2]) {
-        dp[i2][j2] = dp[i2 + 1][j2 + 1] + 1;
-      } else {
-        dp[i2][j2] = Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
-      }
-    }
-  }
-  const matches = [];
-  let i = 0;
-  let j = 0;
-  while (i < m && j < n) {
-    if (a[i] === b[j]) {
-      matches.push({ ai: i, bi: j });
-      i++;
-      j++;
-    } else if (dp[i + 1]?.[j] ?? 0 >= (dp[i]?.[j + 1] ?? 0)) {
-      i++;
-    } else {
-      j++;
-    }
-  }
-  return matches;
-}
-function simpleLCS(a, b) {
-  const matches = [];
-  let bi = 0;
-  for (let ai = 0; ai < a.length && bi < b.length; ai++) {
-    const idx = b.indexOf(a[ai], bi);
-    if (idx !== -1) {
-      matches.push({ ai, bi: idx });
-      bi = idx + 1;
-    }
-  }
-  return matches;
-}
-
 // src/init.ts
 async function init(cwd, localRepo) {
-  p5.intro("projx init");
+  p6.intro("projx init");
   const isLocal = !!localRepo;
-  if (existsSync6(join7(cwd, ".projx"))) {
-    p5.log.error("This project is already initialized. Use 'projx update' or 'projx add' instead.");
+  if (existsSync7(join8(cwd, ".projx"))) {
+    p6.log.error("This project is already initialized. Use 'projx update' or '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.`);
     process.exit(1);
   }
-  const spinner5 = p5.spinner();
+  if (hasUncommittedChanges2(cwd)) {
+    p6.log.error("You have uncommitted changes. Commit or stash them first.");
+    process.exit(1);
+  }
+  const spinner5 = p6.spinner();
   spinner5.start("Scanning for components");
   const detected = await detectComponents(cwd);
   spinner5.stop(
@@ -1282,7 +1120,7 @@ async function init(cwd, localRepo) {
     confirmed = await manualSelect(cwd);
   }
   if (confirmed.length === 0) {
-    p5.log.warn("No components selected. Nothing to do.");
+    p6.log.warn("No components selected. Nothing to do.");
     process.exit(0);
   }
   const components = confirmed.map((c) => c.component);
@@ -1291,55 +1129,51 @@ async function init(cwd, localRepo) {
   );
   const projectName = toKebab(cwd.split("/").pop());
   const vars = { projectName, components, paths };
-  const dlSpinner = p5.spinner();
+  const dlSpinner = p6.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));
+    p6.log.error(String(err));
     process.exit(1);
   });
   dlSpinner.stop(isLocal ? "Local templates loaded." : "Templates downloaded.");
   try {
-    for (const { component, directory } of confirmed) {
-      const dir = join7(cwd, directory);
-      if (existsSync6(dir)) {
-        await writeComponentMarker(dir, component);
-        p5.log.success(`${directory}/.projx-component`);
-      }
-    }
-    await generateSharedFiles(cwd, repoDir, vars);
-    const pkg = JSON.parse(
-      await readFile6(join7(repoDir, "cli/package.json"), "utf-8")
+    const pkg = JSON.parse(await readFile6(join8(repoDir, "cli/package.json"), "utf-8"));
+    const version = pkg.version;
+    const baselineSpinner = p6.spinner();
+    baselineSpinner.start("Creating template baseline");
+    await createBaseline(cwd, repoDir, components, paths, vars, version, "init");
+    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
     );
-    const projxConfig = {
-      version: pkg.version,
-      components,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-      paths
-    };
-    await writeFile5(join7(cwd, ".projx"), JSON.stringify(projxConfig, null, 2));
-    p5.log.success(".projx");
-    if (isGitRepo2(cwd)) {
+    mergeSpinner.stop("Baseline merged. Your code is preserved.");
+    if (!existsSync7(join8(cwd, ".githooks"))) {
       try {
-        execSync3("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
-        p5.log.success("Git hooks configured.");
+        execSync4("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
+        p6.log.success("Git hooks configured.");
       } catch {
-        p5.log.warn("Failed to configure git hooks.");
+        p6.log.warn("Failed to configure git hooks.");
       }
     }
   } finally {
     await cleanupRepo(repoDir, isLocal);
   }
-  p5.outro("Project initialized. Run './setup.sh' to install dependencies.\n\n  Like projx? Star it: https://github.com/ukanhaupa/projx");
+  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 p5.confirm({
+    const yes = await p6.confirm({
       message: `Found ${LABELS[d.component].label} in ${d.directory}/ \u2014 register as "${d.component}"?`,
       initialValue: true
     });
-    if (p5.isCancel(yes)) process.exit(0);
+    if (p6.isCancel(yes)) process.exit(0);
     if (yes) {
       confirmed.push({ component: d.component, directory: d.directory });
     }
@@ -1347,7 +1181,7 @@ async function confirmDetections(detected) {
   return confirmed;
 }
 async function manualSelect(cwd) {
-  const selected = await p5.multiselect({
+  const selected = await p6.multiselect({
     message: "No components detected. Select manually:",
     options: COMPONENTS.map((c) => ({
       value: c,
@@ -1356,140 +1190,39 @@ async function manualSelect(cwd) {
     })),
     required: false
   });
-  if (p5.isCancel(selected)) process.exit(0);
+  if (p6.isCancel(selected)) process.exit(0);
   const result = [];
   for (const component of selected) {
-    const dir = await p5.text({
+    const dir = await p6.text({
       message: `Directory for ${LABELS[component].label}?`,
       placeholder: component,
       defaultValue: component
     });
-    if (p5.isCancel(dir)) process.exit(0);
-    if (!existsSync6(join7(cwd, dir))) {
-      p5.log.warn(`${dir}/ does not exist \u2014 skipping.`);
+    if (p6.isCancel(dir)) process.exit(0);
+    if (!existsSync7(join8(cwd, dir))) {
+      p6.log.warn(`${dir}/ does not exist \u2014 skipping.`);
       continue;
     }
     result.push({ component, directory: dir });
   }
   return result;
 }
-async function generateSharedFiles(cwd, repoDir, vars) {
-  const files = [];
-  const hasBackend = vars.components.includes("fastapi") || vars.components.includes("fastify");
-  if (hasBackend || vars.components.includes("frontend")) {
-    files.push(
-      { path: "docker-compose.yml", content: await generateDockerCompose(vars) },
-      { path: "docker-compose.dev.yml", content: await generateDockerComposeDev(vars) }
-    );
-  }
-  files.push(
-    { path: "README.md", content: await generateReadme(vars) },
-    { path: ".githooks/pre-commit", content: await generatePreCommit(vars), mode: 493 },
-    { path: ".github/workflows/ci.yml", content: await generateCiYml(vars) },
-    { path: "setup.sh", content: await generateSetupSh(vars), mode: 493 }
-  );
-  for (const file of files) {
-    const dest = join7(cwd, file.path);
-    const dir = dest.substring(0, dest.lastIndexOf("/"));
-    if (dir !== cwd) await mkdir5(dir, { recursive: true });
-    const existing = await readFileOrNull(dest);
-    if (existing === null) {
-      await writeFile5(dest, file.content);
-      if (file.mode) await chmod4(dest, file.mode);
-      p5.log.success(file.path);
-    } else if (existing === file.content) {
-      p5.log.info(`${file.path} \u2014 identical, skipped.`);
-    } else {
-      const action = await resolveConflict(file.path, existing, file.content);
-      if (action === "overwrite") {
-        await writeFile5(dest, file.content);
-        if (file.mode) await chmod4(dest, file.mode);
-        p5.log.success(`${file.path} \u2014 overwritten.`);
-      } else {
-        p5.log.info(`${file.path} \u2014 kept existing.`);
-      }
-    }
-  }
-  const statics = [".editorconfig"];
-  for (const file of statics) {
-    const src = join7(repoDir, file);
-    const dest = join7(cwd, file);
-    if (!existsSync6(src)) continue;
-    if (!existsSync6(dest)) {
-      await cp3(src, dest);
-      p5.log.success(file);
-    } else {
-      const existing = await readFileOrNull(dest);
-      const template = await readFileOrNull(src);
-      if (existing === template) {
-        p5.log.info(`${file} \u2014 identical, skipped.`);
-      } else {
-        const action = await resolveConflict(file, existing ?? "", template ?? "");
-        if (action === "overwrite") {
-          await cp3(src, dest, { force: true });
-          p5.log.success(`${file} \u2014 overwritten.`);
-        } else {
-          p5.log.info(`${file} \u2014 kept existing.`);
-        }
-      }
-    }
-  }
-  const vscodeDest = join7(cwd, ".vscode");
-  await mkdir5(vscodeDest, { recursive: true });
-  const settingsPath = join7(vscodeDest, "settings.json");
-  const settingsContent = generateVscodeSettings(vars);
-  const existingSettings = await readFileOrNull(settingsPath);
-  if (existingSettings === null) {
-    await writeFile5(settingsPath, settingsContent);
-    p5.log.success(".vscode/settings.json");
-  } else if (existingSettings !== settingsContent) {
-    const action = await resolveConflict(".vscode/settings.json", existingSettings, settingsContent);
-    if (action === "overwrite") {
-      await writeFile5(settingsPath, settingsContent);
-      p5.log.success(".vscode/settings.json \u2014 overwritten.");
-    } else {
-      p5.log.info(".vscode/settings.json \u2014 kept existing.");
-    }
-  }
-  const extSrc = join7(repoDir, ".vscode/extensions.json");
-  const extDest = join7(vscodeDest, "extensions.json");
-  if (existsSync6(extSrc) && !existsSync6(extDest)) {
-    await cp3(extSrc, extDest);
-    p5.log.success(".vscode/extensions.json");
-  }
-}
-async function resolveConflict(filePath, existing, template) {
-  let action = await p5.select({
-    message: `${filePath} differs from projx template`,
-    options: [
-      { value: "diff", label: "View diff" },
-      { value: "overwrite", label: "Overwrite with template" },
-      { value: "skip", label: "Skip (keep existing)" }
-    ]
-  });
-  if (p5.isCancel(action)) process.exit(0);
-  if (action === "diff") {
-    const diff = unifiedDiff(existing, template, filePath);
-    p5.log.message(diff);
-    action = await p5.select({
-      message: `${filePath}`,
-      options: [
-        { value: "overwrite", label: "Overwrite with template" },
-        { value: "skip", label: "Skip (keep existing)" }
-      ]
-    });
-    if (p5.isCancel(action)) process.exit(0);
-  }
-  return action;
-}
 function isGitRepo2(cwd) {
   try {
-    execSync3("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    execSync4("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
   }
 }
+function hasUncommittedChanges2(cwd) {
+  try {
+    const status = execSync4("git status --porcelain", { cwd, stdio: "pipe" }).toString().trim();
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
 
 // src/index.ts
 var args = process.argv.slice(2);
@@ -1615,7 +1348,7 @@ async function main() {
     opts.install = options.install ?? opts.install;
   }
   const dest = resolve2(process.cwd(), opts.name);
-  if (existsSync7(dest)) {
+  if (existsSync8(dest)) {
     console.error(`Error: ${dest} already exists.`);
     process.exit(1);
   }