create-projx 1.5.5 → 1.5.6

package/dist/baseline-72Z7TC2E.js

@@ -0,0 +1,27 @@
+import {
+  BASELINE_REF,
+  applyTemplate,
+  buildDisplayNames,
+  buildPathsUpper,
+  collectAllFiles,
+  detectPackageNameOverrides,
+  getBaselineRef,
+  getFileAtRef,
+  matchesSkip,
+  saveBaselineRef,
+  writeTemplateToDir
+} from "./chunk-G74HYIE4.js";
+import "./chunk-FTHX7ILT.js";
+export {
+  BASELINE_REF,
+  applyTemplate,
+  buildDisplayNames,
+  buildPathsUpper,
+  collectAllFiles,
+  detectPackageNameOverrides,
+  getBaselineRef,
+  getFileAtRef,
+  matchesSkip,
+  saveBaselineRef,
+  writeTemplateToDir
+};

package/dist/chunk-FTHX7ILT.js

@@ -0,0 +1,424 @@
+// src/utils.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync } 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"
+];
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function pmCommands(pm) {
+  switch (pm) {
+    case "npm":
+      return { name: "npm", install: "npm install", ci: "npm ci", run: "npm run", exec: "npx", dlx: "npx", lockfile: "package-lock.json", prismaExec: "npx prisma", runDev: "npm run dev" };
+    case "pnpm":
+      return { name: "pnpm", install: "pnpm install", ci: "pnpm install --frozen-lockfile", run: "pnpm", exec: "pnpm exec", dlx: "pnpm dlx", lockfile: "pnpm-lock.yaml", prismaExec: "pnpm prisma", runDev: "pnpm dev" };
+    case "yarn":
+      return { name: "yarn", install: "yarn", ci: "yarn --frozen-lockfile", run: "yarn", exec: "yarn", dlx: "yarn dlx", lockfile: "yarn.lock", prismaExec: "yarn prisma", runDev: "yarn dev" };
+    case "bun":
+      return { name: "bun", install: "bun install", ci: "bun install --frozen-lockfile", run: "bun run", exec: "bunx", dlx: "bunx", lockfile: "bun.lockb", prismaExec: "bunx prisma", runDev: "bun run dev" };
+  }
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "bun.lockb"))) return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(cwd, "package-lock.json"))) return "npm";
+  return null;
+}
+function detectPackageManagerFromComponents(cwd, componentPaths) {
+  const jsComponents = ["fastify", "frontend", "e2e"];
+  for (const component of jsComponents) {
+    const dir = componentPaths[component];
+    if (!dir) continue;
+    const fullDir = join(cwd, dir);
+    if (!existsSync(fullDir)) continue;
+    const detected = detectPackageManager(fullDir);
+    if (detected) return detected;
+  }
+  return detectPackageManager(cwd);
+}
+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 toTitle(s) {
+  return s.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+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"];
+  for (const file of statics) {
+    const src = join(tpl, file);
+    if (existsSync(src)) {
+      await cp(src, join(dest, file));
+      manifest.push(file);
+    }
+  }
+  const extensionsJson = join(tpl, ".vscode/extensions.json");
+  if (existsSync(extensionsJson)) {
+    await mkdir(join(dest, ".vscode"), { recursive: true });
+    await cp(extensionsJson, join(dest, ".vscode/extensions.json"));
+    manifest.push(".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);
+    }
+  }
+}
+var COMPONENT_MARKER = ".projx-component";
+async function readFileOrNull(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseMarker(raw) {
+  try {
+    const data = JSON.parse(raw);
+    let component;
+    if (typeof data.component === "string" && COMPONENTS.includes(data.component)) {
+      component = data.component;
+    } else if (Array.isArray(data.components) && data.components.length > 0) {
+      const first = data.components[0];
+      if (typeof first === "string" && COMPONENTS.includes(first)) {
+        component = first;
+      }
+    }
+    if (!component) return null;
+    return {
+      component,
+      skip: Array.isArray(data.skip) ? data.skip : []
+    };
+  } catch {
+    return null;
+  }
+}
+async function readComponentMarker(dir) {
+  const raw = await readFileOrNull(join(dir, COMPONENT_MARKER));
+  if (!raw) return null;
+  return parseMarker(raw);
+}
+async function writeComponentMarker(dir, data) {
+  const markerPath = join(dir, COMPONENT_MARKER);
+  const out = {
+    component: data.component,
+    skip: Array.isArray(data.skip) ? data.skip : []
+  };
+  await writeFile(markerPath, JSON.stringify(out, null, 2) + "\n");
+}
+async function upsertComponentMarker(dir, component, skip) {
+  const existing = await readComponentMarker(dir);
+  await writeComponentMarker(dir, {
+    component,
+    skip: skip ?? existing?.skip ?? []
+  });
+}
+async function readProjxConfig(cwd) {
+  const path = join(cwd, ".projx");
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(await readFile(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function writeProjxConfig(cwd, data) {
+  const path = join(cwd, ".projx");
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const out = { ...data };
+  if (typeof out.createdAt !== "string") out.createdAt = today;
+  if (!Array.isArray(out.skip)) out.skip = [];
+  await writeFile(path, JSON.stringify(out, null, 2) + "\n");
+}
+var DEFAULT_ROOT_SKIP_PATTERNS = [
+  "docker-compose.yml",
+  "docker-compose.dev.yml",
+  "README.md",
+  ".githooks/pre-commit",
+  ".github/workflows/ci.yml",
+  "setup.sh"
+];
+var DEFAULT_COMPONENT_SKIP_PATTERNS = {
+  fastapi: ["pyproject.toml"],
+  fastify: ["package.json"],
+  frontend: ["package.json"],
+  e2e: ["package.json"],
+  mobile: ["pubspec.yaml"]
+};
+async function discoverComponentPaths(cwd, components) {
+  const { paths: discovered } = await discoverComponentsFromMarkers(cwd);
+  const paths = { ...discovered };
+  for (const c of components) {
+    if (!paths[c]) paths[c] = c;
+  }
+  return paths;
+}
+async function discoverComponentsFromMarkers(cwd) {
+  const components = [];
+  const paths = {};
+  if (!existsSync(cwd)) return { components, paths };
+  const entries = await readdir(cwd, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (EXCLUDE.has(entry.name)) continue;
+    if (entry.name.startsWith(".")) continue;
+    const marker = await readComponentMarker(join(cwd, entry.name));
+    if (!marker) continue;
+    if (!components.includes(marker.component)) {
+      components.push(marker.component);
+      paths[marker.component] = entry.name;
+    }
+  }
+  for (const c of components) {
+    if (!paths[c]) paths[c] = c;
+  }
+  return { components, paths };
+}
+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 pmName = vars.pm?.name ?? "npm";
+      const fn = new Function("components", "projectName", "pm", `return ${ifMatch[1]}`);
+      const result = fn(components, projectName, pmName);
+      stack.push({ active: result, matched: result });
+      continue;
+    }
+    const elseIfMatch = line.match(/^<%\s*\}\s*else\s+if\s*\((.+?)\)\s*\{?\s*%>$/);
+    if (elseIfMatch) {
+      if (stack.length > 0) {
+        const top = stack[stack.length - 1];
+        if (top.matched) {
+          top.active = false;
+        } else {
+          const pmN = vars.pm?.name ?? "npm";
+          const fn = new Function("components", "projectName", "pm", `return ${elseIfMatch[1]}`);
+          const result = fn(components, projectName, pmN);
+          top.active = result;
+          if (result) top.matched = true;
+        }
+      }
+      continue;
+    }
+    if (/^<%\s*\}\s*else\s*\{?\s*%>$/.test(line)) {
+      if (stack.length > 0) {
+        const top = stack[stack.length - 1];
+        top.active = !top.matched;
+      }
+      continue;
+    }
+    if (/^<%\s*\}?\s*%>$/.test(line)) {
+      stack.pop();
+      continue;
+    }
+    if (stack.length > 0 && stack.some((v) => !v.active)) continue;
+    const replaced = line.replace(
+      /<%=\s*([\w.]+)\s*%>/g,
+      (_, expr) => {
+        const parts = expr.split(".");
+        let val = vars;
+        for (const p of parts) {
+          val = val?.[p];
+        }
+        return String(val ?? "");
+      }
+    );
+    output.push(replaced);
+  }
+  return output.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function detectProjectName(cwd, components, componentPaths) {
+  for (const component of components) {
+    const dir = componentPaths[component] ?? component;
+    const pkgPath = join(cwd, dir, "package.json");
+    if (existsSync(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());
+}
+
+export {
+  REPO,
+  REPO_URL,
+  COMPONENTS,
+  PACKAGE_MANAGERS,
+  pmCommands,
+  detectPackageManager,
+  detectPackageManagerFromComponents,
+  toKebab,
+  toSnake,
+  toTitle,
+  hasCommand,
+  exec,
+  sharedTemplateDir,
+  downloadRepo,
+  cleanupRepo,
+  EXCLUDE,
+  copyComponent,
+  copyStaticFiles,
+  replaceInFile,
+  replaceInDir,
+  COMPONENT_MARKER,
+  readFileOrNull,
+  readComponentMarker,
+  writeComponentMarker,
+  upsertComponentMarker,
+  readProjxConfig,
+  writeProjxConfig,
+  DEFAULT_ROOT_SKIP_PATTERNS,
+  DEFAULT_COMPONENT_SKIP_PATTERNS,
+  discoverComponentPaths,
+  discoverComponentsFromMarkers,
+  render,
+  detectProjectName
+};