create-projx 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/utils.ts
@@ -176,6 +176,47 @@ async function replaceInDir(dir, find, replace, ext) {
     }
   }
 }
+var COMPONENT_MARKER = ".projx-component";
+async function readFileOrNull(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeComponentMarker(dir, component) {
+  await writeFile(
+    join(dir, COMPONENT_MARKER),
+    JSON.stringify({ component }, null, 2) + "\n"
+  );
+}
+async function discoverComponentPaths(cwd, components) {
+  const paths = {};
+  const scan = async (dir) => {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (EXCLUDE.has(entry.name)) continue;
+      if (entry.name.startsWith(".")) continue;
+      const full = join(dir, entry.name);
+      const marker = join(full, COMPONENT_MARKER);
+      if (existsSync(marker)) {
+        try {
+          const data = JSON.parse(await readFile(marker, "utf-8"));
+          if (components.includes(data.component)) {
+            paths[data.component] = entry.name;
+          }
+        } catch {
+        }
+      }
+    }
+  };
+  await scan(cwd);
+  for (const c of components) {
+    if (!paths[c]) paths[c] = c;
+  }
+  return paths;
+}
 function render(template, vars) {
   const components = vars.components;
   const projectName = vars.projectName;
@@ -201,8 +242,15 @@ function render(template, vars) {
     }
     if (stack.length > 0 && stack.some((v) => !v)) continue;
     const replaced = line.replace(
-      /<%=\s*(\w+)\s*%>/g,
-      (_, key) => String(vars[key] ?? "")
+      /<%=\s*([\w.]+)\s*%>/g,
+      (_, expr) => {
+        const parts = expr.split(".");
+        let val = vars;
+        for (const p6 of parts) {
+          val = val?.[p6];
+        }
+        return String(val ?? "");
+      }
     );
     output.push(replaced);
   }
@@ -288,7 +336,10 @@ async function generateReadme(vars) {
 async function scaffold(opts, dest, localRepo) {
   const name = toKebab(opts.name);
   const nameSnake = toSnake(opts.name);
-  const vars = { projectName: name, components: opts.components };
+  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();
@@ -307,42 +358,28 @@ async function scaffold(opts, dest, localRepo) {
 }
 async function doScaffold(opts, dest, repoDir, name, nameSnake, vars) {
   p2.log.info(`Scaffolding project in ${dest}`);
-  const manifest = [];
   for (const component of opts.components) {
-    const spinner4 = p2.spinner();
-    spinner4.start(`Copying ${component}/`);
-    const files = await copyComponent(repoDir, component, dest);
-    manifest.push(...files.map((f) => `${component}/${f}`));
-    spinner4.stop(`${component}/`);
+    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")) {
-    const dc = await generateDockerCompose(vars);
-    await writeFile2(join3(dest, "docker-compose.yml"), dc);
-    manifest.push("docker-compose.yml");
-    const dcDev = await generateDockerComposeDev(vars);
-    await writeFile2(join3(dest, "docker-compose.dev.yml"), dcDev);
-    manifest.push("docker-compose.dev.yml");
-  }
-  const readme = await generateReadme(vars);
-  await writeFile2(join3(dest, "README.md"), readme);
-  manifest.push("README.md");
+    await writeFile2(join3(dest, "docker-compose.yml"), await generateDockerCompose(vars));
+    await writeFile2(join3(dest, "docker-compose.dev.yml"), await generateDockerComposeDev(vars));
+  }
+  await writeFile2(join3(dest, "README.md"), await generateReadme(vars));
   await mkdir2(join3(dest, ".githooks"), { recursive: true });
-  const preCommit = await generatePreCommit(vars);
-  await writeFile2(join3(dest, ".githooks/pre-commit"), preCommit);
+  await writeFile2(join3(dest, ".githooks/pre-commit"), await generatePreCommit(vars));
   await chmod(join3(dest, ".githooks/pre-commit"), 493);
-  manifest.push(".githooks/pre-commit");
   await mkdir2(join3(dest, ".github/workflows"), { recursive: true });
-  const lintYml = await generateCiYml(vars);
-  await writeFile2(join3(dest, ".github/workflows/ci.yml"), lintYml);
-  manifest.push(".github/workflows/ci.yml");
-  const setupSh = await generateSetupSh(vars);
-  await writeFile2(join3(dest, "setup.sh"), setupSh);
+  await writeFile2(join3(dest, ".github/workflows/ci.yml"), await generateCiYml(vars));
+  await writeFile2(join3(dest, "setup.sh"), await generateSetupSh(vars));
   await chmod(join3(dest, "setup.sh"), 493);
-  manifest.push("setup.sh");
-  const staticFiles = await copyStaticFiles(repoDir, dest);
-  manifest.push(...staticFiles);
+  await copyStaticFiles(repoDir, dest);
   const pkg = JSON.parse(
     await readFile3(join3(repoDir, "cli/package.json"), "utf-8")
   );
@@ -350,7 +387,7 @@ async function doScaffold(opts, dest, repoDir, name, nameSnake, vars) {
     version: pkg.version,
     components: opts.components,
     createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-    files: manifest.sort()
+    paths: vars.paths
   };
   await writeFile2(join3(dest, ".projx"), JSON.stringify(projxConfig, null, 2));
   if (opts.git) {
@@ -377,7 +414,9 @@ async function doScaffold(opts, dest, repoDir, name, nameSnake, vars) {
   p2.outro(`Done! Next steps:
 
   cd ${name}
-  ./setup.sh`);
+  ./setup.sh
+
+  Like projx? Star it: https://github.com/ukanhaupa/projx`);
 }
 async function substituteNames(dest, components, name, nameSnake) {
   if (components.includes("fastapi")) {
@@ -424,44 +463,44 @@ async function substituteNames(dest, components, name, nameSnake) {
 }
 async function installDeps(dest, components) {
   for (const component of components) {
-    const spinner4 = p2.spinner();
+    const spinner5 = p2.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
-            spinner4.start("Installing FastAPI dependencies (uv sync)");
+            spinner5.start("Installing FastAPI dependencies (uv sync)");
             exec("uv sync --all-extras", join3(dest, "fastapi"));
-            spinner4.stop("FastAPI dependencies installed.");
+            spinner5.stop("FastAPI dependencies installed.");
           } else {
             p2.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand("pnpm")) {
-            spinner4.start("Installing Fastify dependencies (pnpm install)");
+            spinner5.start("Installing Fastify dependencies (pnpm install)");
             exec("pnpm install", join3(dest, "fastify"));
-            spinner4.stop("Fastify dependencies installed.");
+            spinner5.stop("Fastify dependencies installed.");
           } else {
-            spinner4.start("Installing Fastify dependencies (npm install)");
+            spinner5.start("Installing Fastify dependencies (npm install)");
             exec("npm install", join3(dest, "fastify"));
-            spinner4.stop("Fastify dependencies installed.");
+            spinner5.stop("Fastify dependencies installed.");
           }
           break;
         case "frontend":
-          spinner4.start("Installing Frontend dependencies (npm install)");
+          spinner5.start("Installing Frontend dependencies (npm install)");
           exec("npm install", join3(dest, "frontend"));
-          spinner4.stop("Frontend dependencies installed.");
+          spinner5.stop("Frontend dependencies installed.");
           break;
         case "e2e":
-          spinner4.start("Installing E2E dependencies (npm install)");
+          spinner5.start("Installing E2E dependencies (npm install)");
           exec("npm install", join3(dest, "e2e"));
-          spinner4.stop("E2E dependencies installed.");
+          spinner5.stop("E2E dependencies installed.");
           break;
         case "mobile":
           if (hasCommand("flutter")) {
-            spinner4.start("Installing Flutter dependencies");
+            spinner5.start("Installing Flutter dependencies");
             exec("flutter pub get", join3(dest, "mobile"));
-            spinner4.stop("Flutter dependencies installed.");
+            spinner5.stop("Flutter dependencies installed.");
           } else {
             p2.log.warn(
               "Flutter not found \u2014 run 'cd mobile && flutter pub get' manually."
@@ -472,7 +511,7 @@ async function installDeps(dest, components) {
           break;
       }
     } catch {
-      spinner4.stop(`Failed to install ${component} dependencies.`);
+      spinner5.stop(`Failed to install ${component} dependencies.`);
     }
   }
 }
@@ -499,7 +538,8 @@ var NEVER_OVERWRITE = [
   /\.env$/,
   /\.env\.(dev|staging|prod)$/,
   /prisma\/migrations\//,
-  /src\/migrations\/versions\//
+  /src\/migrations\/versions\//,
+  /\.projx-component$/
 ];
 function isGitRepo(cwd) {
   try {
@@ -550,11 +590,17 @@ async function update(cwd, localRepo) {
     config = {
       version: "0.0.0",
       components: detected,
-      createdAt: "unknown",
-      files: []
+      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) {
+      p3.log.info(`${c} \u2192 ${componentPaths[c]}/`);
+    }
+  }
   const useGitBranch = isGitRepo(cwd);
   let branchName;
   let originalBranch;
@@ -584,7 +630,7 @@ async function update(cwd, localRepo) {
     execSync2(`git checkout -b ${branchName}`, { cwd, stdio: "pipe" });
     p3.log.info(`Created branch: ${branchName}`);
     try {
-      await doUpdate(cwd, config, repoDir, pkg.version);
+      await doUpdate(cwd, config, repoDir, pkg.version, componentPaths);
     } finally {
       await cleanupRepo(repoDir, isLocal);
     }
@@ -612,76 +658,73 @@ async function update(cwd, localRepo) {
       await readFile4(join4(repoDir, "cli/package.json"), "utf-8")
     );
     try {
-      await doUpdate(cwd, config, repoDir, pkg.version);
+      await doUpdate(cwd, config, repoDir, pkg.version, componentPaths);
     } finally {
       await cleanupRepo(repoDir, isLocal);
     }
     p3.outro(`Updated to v${pkg.version}. Review changes before committing.`);
   }
 }
-async function doUpdate(cwd, config, repoDir, version) {
-  const name = detectProjectName(cwd, config.components);
+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 };
-  const newManifest = [];
+  const vars = { projectName: name, components: config.components, paths: componentPaths };
   for (const component of config.components) {
-    const spinner5 = p3.spinner();
-    spinner5.start(`Updating ${component}/ template files`);
+    const targetDir = componentPaths[component];
+    const spinner6 = p3.spinner();
+    spinner6.start(`Updating ${targetDir}/ (${component})`);
     const componentSrc = join4(repoDir, component);
     if (!existsSync3(componentSrc)) {
-      spinner5.stop(`${component}/ template not found, skipping.`);
+      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 rel = `${component}/${file}`;
       const src = join4(tmpDest, component, file);
-      const dest = join4(cwd, rel);
-      if (NEVER_OVERWRITE.some((re) => re.test(rel))) continue;
-      if (config.files.length > 0 && !config.files.includes(rel)) continue;
+      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 });
       await cp2(src, dest, { force: true });
-      newManifest.push(rel);
     }
     await rm2(tmpDest, { recursive: true, force: true });
-    spinner5.stop(`${component}/ updated.`);
+    if (!existsSync3(join4(cwd, targetDir, ".projx-component"))) {
+      await writeComponentMarker(join4(cwd, targetDir), component);
+    }
+    spinner6.stop(`${targetDir}/ updated.`);
   }
-  const spinner4 = p3.spinner();
-  spinner4.start("Updating shared files");
+  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)
     );
-    newManifest.push("docker-compose.yml");
     await writeFile3(
       join4(cwd, "docker-compose.dev.yml"),
       await generateDockerComposeDev(vars)
     );
-    newManifest.push("docker-compose.dev.yml");
   }
   await mkdir3(join4(cwd, ".githooks"), { recursive: true });
   const preCommit = await generatePreCommit(vars);
   await writeFile3(join4(cwd, ".githooks/pre-commit"), preCommit);
   await chmod2(join4(cwd, ".githooks/pre-commit"), 493);
-  newManifest.push(".githooks/pre-commit");
   await mkdir3(join4(cwd, ".github/workflows"), { recursive: true });
   await writeFile3(
     join4(cwd, ".github/workflows/ci.yml"),
     await generateCiYml(vars)
   );
-  newManifest.push(".github/workflows/ci.yml");
   const setupSh = await generateSetupSh(vars);
   await writeFile3(join4(cwd, "setup.sh"), setupSh);
   await chmod2(join4(cwd, "setup.sh"), 493);
-  newManifest.push("setup.sh");
-  spinner4.stop("Shared files updated.");
+  spinner5.stop("Shared files updated.");
   if (config.components.includes("mobile")) {
+    const mobilePath = componentPaths.mobile ?? "mobile";
     await replaceInDir(
-      join4(cwd, "mobile"),
+      join4(cwd, mobilePath),
       "package:projx_mobile/",
       `package:${nameSnake}_mobile/`,
       ".dart"
@@ -691,13 +734,14 @@ async function doUpdate(cwd, config, repoDir, version) {
     version,
     components: config.components,
     createdAt: config.createdAt,
-    files: [.../* @__PURE__ */ new Set([...config.files, ...newManifest])].sort()
+    paths: componentPaths
   };
   await writeFile3(join4(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2));
 }
-function detectProjectName(cwd, components) {
+function detectProjectName(cwd, components, componentPaths) {
   for (const component of components) {
-    const pkgPath = join4(cwd, component, "package.json");
+    const dir = componentPaths[component] ?? component;
+    const pkgPath = join4(cwd, dir, "package.json");
     if (existsSync3(pkgPath)) {
       try {
         const pkg = JSON.parse(
@@ -754,44 +798,37 @@ async function add(cwd, newComponents, localRepo, skipInstall = false) {
   }
 }
 async function doAdd(cwd, config, toAdd, repoDir, skipInstall) {
-  const name = detectProjectName2(cwd, config.components);
-  const nameSnake = toSnake(name);
   const allComponents = [...config.components, ...toAdd];
-  const vars = { projectName: name, components: allComponents };
-  const newFiles = [];
+  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 spinner5 = p4.spinner();
-    spinner5.start(`Adding ${component}/`);
-    const files = await copyComponent(repoDir, component, cwd);
-    newFiles.push(...files.map((f) => `${component}/${f}`));
-    spinner5.stop(`${component}/`);
+    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 spinner4 = p4.spinner();
-  spinner4.start("Regenerating shared files");
+  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, "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, ".github/workflows/ci.yml"), await generateCiYml(vars));
   await writeFile4(join5(cwd, "setup.sh"), await generateSetupSh(vars));
   await chmod3(join5(cwd, "setup.sh"), 493);
-  spinner4.stop("Shared files regenerated.");
+  spinner5.stop("Shared files regenerated.");
   if (!skipInstall) {
     await installDeps2(cwd, toAdd);
   }
@@ -812,10 +849,12 @@ async function doAdd(cwd, config, toAdd, repoDir, skipInstall) {
     version: pkg.version,
     components: allComponents,
     createdAt: config.createdAt,
-    files: [.../* @__PURE__ */ new Set([...config.files, ...newFiles])].sort()
+    paths
   };
   await writeFile4(join5(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2));
-  p4.outro(`Added ${toAdd.join(", ")}. Shared files updated for all ${allComponents.length} components.`);
+  p4.outro(`Added ${toAdd.join(", ")}. Shared files updated for all ${allComponents.length} components.
+
+  Like projx? Star it: https://github.com/ukanhaupa/projx`);
 }
 async function substituteNames2(dest, components, name, nameSnake) {
   if (components.includes("fastapi")) {
@@ -862,44 +901,44 @@ async function substituteNames2(dest, components, name, nameSnake) {
 }
 async function installDeps2(dest, components) {
   for (const component of components) {
-    const spinner4 = p4.spinner();
+    const spinner5 = p4.spinner();
     try {
       switch (component) {
         case "fastapi":
           if (hasCommand("uv")) {
-            spinner4.start("Installing FastAPI dependencies");
+            spinner5.start("Installing FastAPI dependencies");
             exec("uv sync --all-extras", join5(dest, "fastapi"));
-            spinner4.stop("FastAPI dependencies installed.");
+            spinner5.stop("FastAPI dependencies installed.");
           } else {
             p4.log.warn("uv not found \u2014 run 'cd fastapi && uv sync' manually.");
           }
           break;
         case "fastify":
           if (hasCommand("pnpm")) {
-            spinner4.start("Installing Fastify dependencies");
+            spinner5.start("Installing Fastify dependencies");
             exec("pnpm install", join5(dest, "fastify"));
-            spinner4.stop("Fastify dependencies installed.");
+            spinner5.stop("Fastify dependencies installed.");
           } else {
-            spinner4.start("Installing Fastify dependencies");
+            spinner5.start("Installing Fastify dependencies");
             exec("npm install", join5(dest, "fastify"));
-            spinner4.stop("Fastify dependencies installed.");
+            spinner5.stop("Fastify dependencies installed.");
           }
           break;
         case "frontend":
-          spinner4.start("Installing Frontend dependencies");
+          spinner5.start("Installing Frontend dependencies");
           exec("npm install", join5(dest, "frontend"));
-          spinner4.stop("Frontend dependencies installed.");
+          spinner5.stop("Frontend dependencies installed.");
           break;
         case "e2e":
-          spinner4.start("Installing E2E dependencies");
+          spinner5.start("Installing E2E dependencies");
           exec("npm install", join5(dest, "e2e"));
-          spinner4.stop("E2E dependencies installed.");
+          spinner5.stop("E2E dependencies installed.");
           break;
         case "mobile":
           if (hasCommand("flutter")) {
-            spinner4.start("Installing Flutter dependencies");
+            spinner5.start("Installing Flutter dependencies");
             exec("flutter pub get", join5(dest, "mobile"));
-            spinner4.stop("Flutter dependencies installed.");
+            spinner5.stop("Flutter dependencies installed.");
           } else {
             p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
           }
@@ -908,13 +947,14 @@ async function installDeps2(dest, components) {
           break;
       }
     } catch {
-      spinner4.stop(`Failed to install ${component} dependencies.`);
+      spinner5.stop(`Failed to install ${component} dependencies.`);
     }
   }
 }
-function detectProjectName2(cwd, components) {
+function detectProjectName2(cwd, components, paths) {
   for (const component of components) {
-    const pkgPath = join5(cwd, component, "package.json");
+    const dir = paths[component] ?? component;
+    const pkgPath = join5(cwd, dir, "package.json");
     if (existsSync4(pkgPath)) {
       try {
         const pkg = JSON.parse(
@@ -931,6 +971,382 @@ function detectProjectName2(cwd, components) {
   return toKebab(cwd.split("/").pop());
 }
 
+// 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";
+
+// src/detect.ts
+import { existsSync as existsSync5 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join6 } 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 detections = await scanDirectory(full, dir);
+    results.push(...detections);
+  }
+  return results;
+}
+async function scanDirectory(dir, relPath) {
+  const results = [];
+  const pyproject = await readFileOrNull(join6(dir, "pyproject.toml"));
+  if (pyproject && /fastapi/i.test(pyproject)) {
+    results.push({
+      component: "fastapi",
+      directory: relPath,
+      confidence: "high",
+      evidence: "pyproject.toml has fastapi dependency"
+    });
+  }
+  const pkg = await readPkg(dir);
+  if (pkg) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps.fastify) {
+      results.push({
+        component: "fastify",
+        directory: relPath,
+        confidence: "high",
+        evidence: "package.json has fastify dependency"
+      });
+    }
+    if (allDeps.react || allDeps["react-dom"]) {
+      results.push({
+        component: "frontend",
+        directory: relPath,
+        confidence: "high",
+        evidence: "package.json has react dependency"
+      });
+    }
+    if (allDeps["@playwright/test"] || allDeps.playwright) {
+      results.push({
+        component: "e2e",
+        directory: relPath,
+        confidence: "high",
+        evidence: "package.json has playwright dependency"
+      });
+    }
+  }
+  const pubspec = await readFileOrNull(join6(dir, "pubspec.yaml"));
+  if (pubspec && /flutter:/i.test(pubspec)) {
+    results.push({
+      component: "mobile",
+      directory: relPath,
+      confidence: "high",
+      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"));
+  if (hasTf) {
+    results.push({
+      component: "infra",
+      directory: relPath,
+      confidence: "high",
+      evidence: "Terraform .tf files found"
+    });
+  }
+  return results;
+}
+async function readPkg(dir) {
+  const content = await readFileOrNull(join6(dir, "package.json"));
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// 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");
+  const isLocal = !!localRepo;
+  if (existsSync6(join7(cwd, ".projx"))) {
+    p5.log.error("This project is already initialized. Use 'projx update' or 'projx add' instead.");
+    process.exit(1);
+  }
+  const spinner5 = p5.spinner();
+  spinner5.start("Scanning for components");
+  const detected = await detectComponents(cwd);
+  spinner5.stop(
+    detected.length > 0 ? `Found ${detected.length} component(s).` : "No components detected."
+  );
+  let confirmed;
+  if (detected.length > 0) {
+    confirmed = await confirmDetections(detected);
+  } else {
+    confirmed = await manualSelect(cwd);
+  }
+  if (confirmed.length === 0) {
+    p5.log.warn("No components selected. Nothing to do.");
+    process.exit(0);
+  }
+  const components = confirmed.map((c) => c.component);
+  const paths = Object.fromEntries(
+    confirmed.map((c) => [c.component, c.directory])
+  );
+  const projectName = toKebab(cwd.split("/").pop());
+  const vars = { projectName, components, paths };
+  const dlSpinner = p5.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));
+    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 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)) {
+      try {
+        execSync3("git config core.hooksPath .githooks", { cwd, stdio: "pipe" });
+        p5.log.success("Git hooks configured.");
+      } catch {
+        p5.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");
+}
+async function confirmDetections(detected) {
+  const confirmed = [];
+  for (const d of detected) {
+    const yes = await p5.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 (yes) {
+      confirmed.push({ component: d.component, directory: d.directory });
+    }
+  }
+  return confirmed;
+}
+async function manualSelect(cwd) {
+  const selected = await p5.multiselect({
+    message: "No components detected. Select manually:",
+    options: COMPONENTS.map((c) => ({
+      value: c,
+      label: LABELS[c].label,
+      hint: LABELS[c].hint
+    })),
+    required: false
+  });
+  if (p5.isCancel(selected)) process.exit(0);
+  const result = [];
+  for (const component of selected) {
+    const dir = await p5.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.`);
+      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", "LICENSE"];
+  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 vscode = join7(repoDir, ".vscode");
+  if (existsSync6(vscode)) {
+    const vscodeDest = join7(cwd, ".vscode");
+    if (!existsSync6(vscodeDest)) {
+      await cp3(vscode, vscodeDest, { recursive: true });
+      p5.log.success(".vscode/");
+    } else {
+      p5.log.info(".vscode/ \u2014 already exists, skipped.");
+    }
+  }
+}
+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" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/index.ts
 var args = process.argv.slice(2);
 function parseArgs() {
@@ -949,6 +1365,10 @@ function parseArgs() {
       command = "add";
       continue;
     }
+    if (arg === "init" && !name) {
+      command = "init";
+      continue;
+    }
     if (arg === "--components") {
       const val = args[++i];
       if (val) {
@@ -992,6 +1412,7 @@ function printHelp() {
   console.log(`
   Usage:
     projx <name> [options]        Create a new project
+    projx init                    Adopt existing project into projx
     projx add <components...>     Add components to existing project
     projx update                  Update scaffolding to latest
 
@@ -1013,6 +1434,10 @@ function printHelp() {
 }
 async function main() {
   const { command, name, options, localRepo, extraArgs } = parseArgs();
+  if (command === "init") {
+    await init(process.cwd(), localRepo);
+    return;
+  }
   if (command === "update") {
     await update(process.cwd(), localRepo);
     return;
@@ -1046,7 +1471,7 @@ async function main() {
     opts.install = options.install ?? opts.install;
   }
   const dest = resolve2(process.cwd(), opts.name);
-  if (existsSync5(dest)) {
+  if (existsSync7(dest)) {
     console.error(`Error: ${dest} already exists.`);
     process.exit(1);
   }