create-projx 0.1.1

package/dist/index.js

@@ -0,0 +1,1064 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/utils.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import { join, resolve } from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+var REPO = "ukanhaupa/projx";
+var REPO_URL = `https://github.com/${REPO}`;
+var COMPONENTS = [
+  "fastapi",
+  "fastify",
+  "frontend",
+  "mobile",
+  "e2e",
+  "infra"
+];
+function toKebab(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toSnake(s) {
+  return toKebab(s).replace(/-/g, "_");
+}
+function hasCommand(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function exec(cmd, cwd) {
+  execSync(cmd, { cwd, stdio: "pipe" });
+}
+function sharedTemplateDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  return join(thisFile, "../../src/templates");
+}
+async function downloadRepo(localPath) {
+  if (localPath) {
+    return localPath;
+  }
+  const dest = join(tmpdir(), `projx-${Date.now()}`);
+  await mkdir(dest, { recursive: true });
+  if (hasCommand("git")) {
+    execSync(
+      `git clone --depth 1 ${REPO_URL}.git "${dest}/repo"`,
+      { stdio: "pipe" }
+    );
+    return join(dest, "repo");
+  }
+  const tarUrl = `${REPO_URL}/archive/refs/heads/main.tar.gz`;
+  execSync(
+    `curl -sL "${tarUrl}" | tar xz -C "${dest}"`,
+    { stdio: "pipe" }
+  );
+  const entries = await readdir(dest);
+  const extracted = entries.find((e) => e.startsWith("projx-"));
+  if (!extracted) throw new Error("Failed to extract repo archive.");
+  return join(dest, extracted);
+}
+async function cleanupRepo(repoDir, isLocal) {
+  if (isLocal) return;
+  const parent = resolve(repoDir, "..");
+  if (parent.startsWith(tmpdir())) {
+    await rm(parent, { recursive: true, force: true });
+  }
+}
+var EXCLUDE = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "__pycache__",
+  ".dart_tool",
+  ".flutter-plugins",
+  ".flutter-plugins-dependencies",
+  ".venv",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".mypy_cache",
+  "playwright-report",
+  "test-results",
+  ".terraform",
+  "cli"
+]);
+var EXCLUDE_FILES = /* @__PURE__ */ new Set([
+  "uv.lock",
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "pubspec.lock",
+  ".env",
+  ".env.dev",
+  ".env.staging",
+  ".env.prod",
+  "dev.tfplan",
+  ".coverage"
+]);
+async function copyComponent(repoDir, component, dest) {
+  const src = join(repoDir, component);
+  const out = join(dest, component);
+  const files = [];
+  await cp(src, out, {
+    recursive: true,
+    filter: (source) => {
+      const base = source.split("/").pop();
+      if (EXCLUDE.has(base)) return false;
+      if (EXCLUDE_FILES.has(base)) return false;
+      if (base.endsWith(".pyc")) return false;
+      return true;
+    }
+  });
+  await collectFiles(out, out, files);
+  return files;
+}
+async function copyStaticFiles(repoDir, dest) {
+  const manifest = [];
+  const tpl = repoDir;
+  const statics = [".editorconfig", "LICENSE"];
+  for (const file of statics) {
+    const src = join(tpl, file);
+    if (existsSync(src)) {
+      await cp(src, join(dest, file));
+      manifest.push(file);
+    }
+  }
+  const gitignore = join(tpl, ".gitignore");
+  if (existsSync(gitignore)) {
+    await cp(gitignore, join(dest, ".gitignore"));
+    manifest.push(".gitignore");
+  }
+  const vscode = join(tpl, ".vscode");
+  if (existsSync(vscode)) {
+    await cp(vscode, join(dest, ".vscode"), { recursive: true });
+    manifest.push(".vscode/settings.json", ".vscode/extensions.json");
+  }
+  const scripts = join(tpl, "scripts");
+  if (existsSync(scripts)) {
+    await cp(scripts, join(dest, "scripts"), { recursive: true });
+    manifest.push("scripts/setup-ssl.sh");
+  }
+  return manifest;
+}
+async function collectFiles(dir, root, files) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectFiles(full, root, files);
+    } else {
+      files.push(full.slice(root.length + 1));
+    }
+  }
+}
+async function replaceInFile(filePath, find, replace) {
+  if (!existsSync(filePath)) return;
+  const content = await readFile(filePath, "utf-8");
+  if (!content.includes(find)) return;
+  await writeFile(filePath, content.replaceAll(find, replace));
+}
+async function replaceInDir(dir, find, replace, ext) {
+  if (!existsSync(dir)) return;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await replaceInDir(full, find, replace, ext);
+    } else if (entry.name.endsWith(ext)) {
+      await replaceInFile(full, find, replace);
+    }
+  }
+}
+function render(template, vars) {
+  const components = vars.components;
+  const projectName = vars.projectName;
+  const lines = template.split("\n");
+  const output = [];
+  const stack = [];
+  for (const line of lines) {
+    const ifMatch = line.match(/^<%\s*if\s*\((.+?)\)\s*\{?\s*%>$/);
+    if (ifMatch) {
+      const fn = new Function("components", "projectName", `return ${ifMatch[1]}`);
+      stack.push(fn(components, projectName));
+      continue;
+    }
+    if (/^<%\s*\}\s*else\s*\{?\s*%>$/.test(line)) {
+      if (stack.length > 0) {
+        stack[stack.length - 1] = !stack[stack.length - 1];
+      }
+      continue;
+    }
+    if (/^<%\s*\}?\s*%>$/.test(line)) {
+      stack.pop();
+      continue;
+    }
+    if (stack.length > 0 && stack.some((v) => !v)) continue;
+    const replaced = line.replace(
+      /<%=\s*(\w+)\s*%>/g,
+      (_, key) => String(vars[key] ?? "")
+    );
+    output.push(replaced);
+  }
+  return output.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+// src/prompts.ts
+import * as p from "@clack/prompts";
+var LABELS = {
+  fastapi: { label: "FastAPI", hint: "Python \u2014 SQLAlchemy, Alembic, uvicorn" },
+  fastify: { label: "Fastify", hint: "Node.js \u2014 Prisma, TypeBox, TypeScript" },
+  frontend: { label: "Frontend", hint: "React 19 + Vite + React Router" },
+  mobile: { label: "Mobile", hint: "Flutter + Riverpod + GoRouter" },
+  e2e: { label: "E2E Tests", hint: "Playwright" },
+  infra: { label: "Infrastructure", hint: "Terraform + AWS" }
+};
+var DEFAULTS = ["fastify", "frontend", "e2e"];
+async function runPrompts(nameArg) {
+  p.intro("projx");
+  const name = nameArg ?? await p.text({
+    message: "Project name",
+    placeholder: "my-app",
+    validate: (v) => {
+      if (!v) return "Required";
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(v))
+        return "Lowercase, hyphens, no spaces";
+    }
+  });
+  if (p.isCancel(name)) process.exit(0);
+  const components = await p.multiselect({
+    message: "Which components?",
+    options: COMPONENTS.map((c) => ({
+      value: c,
+      label: LABELS[c].label,
+      hint: LABELS[c].hint
+    })),
+    initialValues: DEFAULTS,
+    required: false
+  });
+  if (p.isCancel(components)) process.exit(0);
+  if (components.length === 0) {
+    p.log.warn("No components selected. Creating an empty project.");
+  }
+  return { name, components, git: true, install: true };
+}
+
+// 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 { join as join3 } from "path";
+import * as p2 from "@clack/prompts";
+
+// src/generators/index.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function renderShared(filename, vars) {
+  const tpl = await readFile2(
+    join2(sharedTemplateDir(), filename),
+    "utf-8"
+  );
+  return render(tpl, vars);
+}
+async function generateDockerCompose(vars) {
+  return renderShared("docker-compose.yml.ejs", vars);
+}
+async function generateDockerComposeDev(vars) {
+  return renderShared("docker-compose.dev.yml.ejs", vars);
+}
+async function generateMakefile(vars) {
+  return renderShared("Makefile.ejs", vars);
+}
+async function generatePreCommit(vars) {
+  return renderShared("pre-commit.ejs", vars);
+}
+async function generateSetupSh(vars) {
+  return renderShared("setup.sh.ejs", vars);
+}
+async function generateCiYml(vars) {
+  return renderShared("ci.yml.ejs", vars);
+}
+async function generateReadme(vars) {
+  return renderShared("README.md.ejs", vars);
+}
+
+// src/scaffold.ts
+async function scaffold(opts, dest, localRepo) {
+  const name = toKebab(opts.name);
+  const nameSnake = toSnake(opts.name);
+  const vars = { projectName: name, components: opts.components };
+  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.");
+  try {
+    await doScaffold(opts, dest, repoDir, name, nameSnake, vars);
+  } finally {
+    await cleanupRepo(repoDir, isLocal);
+  }
+}
+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}/`);
+  }
+  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 makefile = await generateMakefile(vars);
+  await writeFile2(join3(dest, "Makefile"), makefile);
+  manifest.push("Makefile");
+  const readme = await generateReadme(vars);
+  await writeFile2(join3(dest, "README.md"), readme);
+  manifest.push("README.md");
+  await mkdir2(join3(dest, ".githooks"), { recursive: true });
+  const preCommit = await generatePreCommit(vars);
+  await writeFile2(join3(dest, ".githooks/pre-commit"), preCommit);
+  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 chmod(join3(dest, "setup.sh"), 493);
+  manifest.push("setup.sh");
+  const staticFiles = await copyStaticFiles(repoDir, dest);
+  manifest.push(...staticFiles);
+  const pkg = JSON.parse(
+    await readFile3(join3(repoDir, "cli/package.json"), "utf-8")
+  );
+  const projxConfig = {
+    version: pkg.version,
+    components: opts.components,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    files: manifest.sort()
+  };
+  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 {
+    }
+  }
+  p2.outro(`Done! Next steps:
+
+  cd ${name}
+  make run-dev`);
+}
+async function substituteNames(dest, components, name, nameSnake) {
+  if (components.includes("fastapi")) {
+    await replaceInFile(
+      join3(dest, "fastapi/pyproject.toml"),
+      "projx-fastapi",
+      `${name}-fastapi`
+    );
+  }
+  if (components.includes("fastify")) {
+    await replaceInFile(
+      join3(dest, "fastify/package.json"),
+      "projx-fastify",
+      `${name}-fastify`
+    );
+  }
+  if (components.includes("frontend")) {
+    await replaceInFile(
+      join3(dest, "frontend/package.json"),
+      "projx-frontend",
+      `${name}-frontend`
+    );
+  }
+  if (components.includes("e2e")) {
+    await replaceInFile(
+      join3(dest, "e2e/package.json"),
+      "projx-e2e",
+      `${name}-e2e`
+    );
+  }
+  if (components.includes("mobile")) {
+    await replaceInFile(
+      join3(dest, "mobile/pubspec.yaml"),
+      "projx_mobile",
+      `${nameSnake}_mobile`
+    );
+    await replaceInDir(
+      join3(dest, "mobile"),
+      "package:projx_mobile/",
+      `package:${nameSnake}_mobile/`,
+      ".dart"
+    );
+  }
+}
+async function installDeps(dest, components) {
+  for (const component of components) {
+    const spinner4 = p2.spinner();
+    try {
+      switch (component) {
+        case "fastapi":
+          if (hasCommand("uv")) {
+            spinner4.start("Installing FastAPI dependencies (uv sync)");
+            exec("uv sync --all-extras", join3(dest, "fastapi"));
+            spinner4.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)");
+            exec("pnpm install", join3(dest, "fastify"));
+            spinner4.stop("Fastify dependencies installed.");
+          } else {
+            spinner4.start("Installing Fastify dependencies (npm install)");
+            exec("npm install", join3(dest, "fastify"));
+            spinner4.stop("Fastify dependencies installed.");
+          }
+          break;
+        case "frontend":
+          spinner4.start("Installing Frontend dependencies (npm install)");
+          exec("npm install", join3(dest, "frontend"));
+          spinner4.stop("Frontend dependencies installed.");
+          break;
+        case "e2e":
+          spinner4.start("Installing E2E dependencies (npm install)");
+          exec("npm install", join3(dest, "e2e"));
+          spinner4.stop("E2E dependencies installed.");
+          break;
+        case "mobile":
+          if (hasCommand("flutter")) {
+            spinner4.start("Installing Flutter dependencies");
+            exec("flutter pub get", join3(dest, "mobile"));
+            spinner4.stop("Flutter dependencies installed.");
+          } else {
+            p2.log.warn(
+              "Flutter not found \u2014 run 'cd mobile && flutter pub get' manually."
+            );
+          }
+          break;
+        case "infra":
+          break;
+      }
+    } catch {
+      spinner4.stop(`Failed to install ${component} dependencies.`);
+    }
+  }
+}
+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)) {
+      try {
+        copyFileSync(example, env);
+      } catch {
+      }
+    }
+  }
+}
+
+// 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\//
+];
+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();
+}
+async function update(cwd, localRepo) {
+  p3.intro("projx update");
+  const isLocal = !!localRepo;
+  const configPath = join4(cwd, ".projx");
+  let config;
+  if (existsSync3(configPath)) {
+    config = JSON.parse(await readFile4(configPath, "utf-8"));
+    p3.log.info(
+      `Found .projx (v${config.version}, components: ${config.components.join(", ")})`
+    );
+  } else {
+    p3.log.warn("No .projx file found. Detecting components from directories.");
+    const detected = COMPONENTS.filter(
+      (c) => existsSync3(join4(cwd, c))
+    );
+    if (detected.length === 0) {
+      p3.log.error("No projx components found in this directory.");
+      process.exit(1);
+    }
+    config = {
+      version: "0.0.0",
+      components: detected,
+      createdAt: "unknown",
+      files: []
+    };
+    p3.log.info(`Detected: ${detected.join(", ")}`);
+  }
+  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}`;
+    }
+    execSync2(`git checkout -b ${branchName}`, { cwd, stdio: "pipe" });
+    p3.log.info(`Created branch: ${branchName}`);
+    try {
+      await doUpdate(cwd, config, repoDir, pkg.version);
+    } finally {
+      await cleanupRepo(repoDir, isLocal);
+    }
+    execSync2(`git checkout ${originalBranch}`, { cwd, stdio: "pipe" });
+    p3.outro(
+      `Updates on branch: ${branchName}
+
+  Review changes:
+    git diff ${originalBranch}...${branchName}
+
+  Merge when ready:
+    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")
+    );
+    try {
+      await doUpdate(cwd, config, repoDir, pkg.version);
+    } 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);
+  const nameSnake = toSnake(name);
+  const vars = { projectName: name, components: config.components };
+  const newManifest = [];
+  for (const component of config.components) {
+    const spinner5 = p3.spinner();
+    spinner5.start(`Updating ${component}/ template files`);
+    const componentSrc = join4(repoDir, component);
+    if (!existsSync3(componentSrc)) {
+      spinner5.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 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.`);
+  }
+  const spinner4 = p3.spinner();
+  spinner4.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.");
+  if (config.components.includes("mobile")) {
+    await replaceInDir(
+      join4(cwd, "mobile"),
+      "package:projx_mobile/",
+      `package:${nameSnake}_mobile/`,
+      ".dart"
+    );
+  }
+  const updatedConfig = {
+    version,
+    components: config.components,
+    createdAt: config.createdAt,
+    files: [.../* @__PURE__ */ new Set([...config.files, ...newManifest])].sort()
+  };
+  await writeFile3(join4(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2));
+}
+function detectProjectName(cwd, components) {
+  for (const component of components) {
+    const pkgPath = join4(cwd, component, "package.json");
+    if (existsSync3(pkgPath)) {
+      try {
+        const pkg = JSON.parse(
+          readFileSync(pkgPath, "utf-8")
+        );
+        const n = pkg.name;
+        if (n && n.includes("-")) {
+          return n.substring(0, n.lastIndexOf("-"));
+        }
+      } catch {
+      }
+    }
+  }
+  return toKebab(cwd.split("/").pop());
+}
+
+// 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";
+async function add(cwd, newComponents, localRepo, skipInstall = false) {
+  p4.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.");
+    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.`);
+  }
+  const toAdd = newComponents.filter((c) => !existing.includes(c));
+  if (toAdd.length === 0) {
+    p4.log.info("Nothing new to add.");
+    process.exit(0);
+  }
+  p4.log.info(`Adding: ${toAdd.join(", ")}`);
+  const dlSpinner = p4.spinner();
+  dlSpinner.start(isLocal ? "Using local templates" : "Downloading latest templates");
+  const repoDir = await downloadRepo(localRepo).catch((err) => {
+    dlSpinner.stop("Failed.");
+    p4.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 name = detectProjectName2(cwd, config.components);
+  const nameSnake = toSnake(name);
+  const allComponents = [...config.components, ...toAdd];
+  const vars = { projectName: name, components: allComponents };
+  const newFiles = [];
+  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}/`);
+  }
+  await substituteNames2(cwd, toAdd, name, nameSnake);
+  const spinner4 = p4.spinner();
+  spinner4.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, "Makefile"), await generateMakefile(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);
+  spinner4.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 pkg = JSON.parse(
+    await readFile5(join5(repoDir, "cli/package.json"), "utf-8")
+  );
+  const updatedConfig = {
+    version: pkg.version,
+    components: allComponents,
+    createdAt: config.createdAt,
+    files: [.../* @__PURE__ */ new Set([...config.files, ...newFiles])].sort()
+  };
+  await writeFile4(join5(cwd, ".projx"), JSON.stringify(updatedConfig, null, 2));
+  p4.outro(`Added ${toAdd.join(", ")}. Shared files updated for all ${allComponents.length} components.`);
+}
+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 spinner4 = p4.spinner();
+    try {
+      switch (component) {
+        case "fastapi":
+          if (hasCommand("uv")) {
+            spinner4.start("Installing FastAPI dependencies");
+            exec("uv sync --all-extras", join5(dest, "fastapi"));
+            spinner4.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");
+            exec("pnpm install", join5(dest, "fastify"));
+            spinner4.stop("Fastify dependencies installed.");
+          } else {
+            spinner4.start("Installing Fastify dependencies");
+            exec("npm install", join5(dest, "fastify"));
+            spinner4.stop("Fastify dependencies installed.");
+          }
+          break;
+        case "frontend":
+          spinner4.start("Installing Frontend dependencies");
+          exec("npm install", join5(dest, "frontend"));
+          spinner4.stop("Frontend dependencies installed.");
+          break;
+        case "e2e":
+          spinner4.start("Installing E2E dependencies");
+          exec("npm install", join5(dest, "e2e"));
+          spinner4.stop("E2E dependencies installed.");
+          break;
+        case "mobile":
+          if (hasCommand("flutter")) {
+            spinner4.start("Installing Flutter dependencies");
+            exec("flutter pub get", join5(dest, "mobile"));
+            spinner4.stop("Flutter dependencies installed.");
+          } else {
+            p4.log.warn("Flutter not found \u2014 run 'cd mobile && flutter pub get' manually.");
+          }
+          break;
+        case "infra":
+          break;
+      }
+    } catch {
+      spinner4.stop(`Failed to install ${component} dependencies.`);
+    }
+  }
+}
+function detectProjectName2(cwd, components) {
+  for (const component of components) {
+    const pkgPath = join5(cwd, component, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(
+          readFileSync2(pkgPath, "utf-8")
+        );
+        const n = pkg.name;
+        if (n && n.includes("-")) {
+          return n.substring(0, n.lastIndexOf("-"));
+        }
+      } catch {
+      }
+    }
+  }
+  return toKebab(cwd.split("/").pop());
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+function parseArgs() {
+  let command = "create";
+  let name;
+  let localRepo;
+  const options = {};
+  const extraArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "update" && !name) {
+      command = "update";
+      continue;
+    }
+    if (arg === "add" && !name) {
+      command = "add";
+      continue;
+    }
+    if (arg === "--components") {
+      const val = args[++i];
+      if (val) {
+        options.components = val.split(",").filter(
+          (c) => COMPONENTS.includes(c)
+        );
+      }
+      continue;
+    }
+    if (arg === "--local") {
+      localRepo = resolve2(args[++i] || ".");
+      continue;
+    }
+    if (arg === "--no-git") {
+      options.git = false;
+      continue;
+    }
+    if (arg === "--no-install") {
+      options.install = false;
+      continue;
+    }
+    if (arg === "-y" || arg === "--yes") {
+      options.components = options.components ?? ["fastify", "frontend", "e2e"];
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+    if (!arg.startsWith("-")) {
+      if (command === "add") {
+        extraArgs.push(arg);
+      } else if (!name) {
+        name = arg;
+      }
+    }
+  }
+  return { command, name, options, localRepo, extraArgs };
+}
+function printHelp() {
+  console.log(`
+  Usage:
+    projx <name> [options]        Create a new project
+    projx add <components...>     Add components to existing project
+    projx update                  Update scaffolding to latest
+
+  Options:
+    --components <list>  Comma-separated: fastapi,fastify,frontend,mobile,e2e,infra
+    --no-git             Skip git init
+    --no-install         Skip dependency installation
+    -y, --yes            Accept defaults (fastify + frontend + e2e)
+    --local <path>       Use local repo instead of downloading (dev only)
+    -h, --help           Show this help
+
+  Examples:
+    npx create-projx my-app
+    npx create-projx my-app --components fastapi,frontend,e2e
+    npx create-projx my-app -y
+    npx create-projx add frontend mobile
+    npx create-projx@latest update
+`);
+}
+async function main() {
+  const { command, name, options, localRepo, extraArgs } = parseArgs();
+  if (command === "update") {
+    await update(process.cwd(), localRepo);
+    return;
+  }
+  if (command === "add") {
+    const components = extraArgs.filter(
+      (c) => COMPONENTS.includes(c)
+    );
+    if (components.length === 0) {
+      console.error(`Error: specify components to add. Available: ${COMPONENTS.join(", ")}`);
+      process.exit(1);
+    }
+    await add(process.cwd(), components, localRepo, options.install === false);
+    return;
+  }
+  let opts;
+  if (options.components) {
+    if (!name) {
+      console.error("Error: project name required. Usage: projx <name>");
+      return process.exit(1);
+    }
+    opts = {
+      name,
+      components: options.components,
+      git: options.git ?? true,
+      install: options.install ?? true
+    };
+  } else {
+    opts = await runPrompts(name);
+    opts.git = options.git ?? opts.git;
+    opts.install = options.install ?? opts.install;
+  }
+  const dest = resolve2(process.cwd(), opts.name);
+  if (existsSync5(dest)) {
+    console.error(`Error: ${dest} already exists.`);
+    process.exit(1);
+  }
+  await scaffold(opts, dest, localRepo);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});