create-newt-app 0.0.2

package/dist/index.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { intro } from "@clack/prompts";
+import chalk from "chalk";
+
+// package.json
+var package_default = {
+  name: "create-newt-app",
+  version: "0.0.2",
+  private: false,
+  type: "module",
+  bin: {
+    "create-newt-app": "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch"
+  },
+  dependencies: {
+    "@clack/prompts": "^0.11.0",
+    "@newt-app/templates": "workspace:*",
+    chalk: "^5.3.0",
+    commander: "^12.1.0",
+    ejs: "^3.1.10",
+    execa: "^9.6.0",
+    zod: "^3.25.76"
+  },
+  devDependencies: {
+    "@types/ejs": "^3.1.5",
+    "@types/node": "^22.0.0",
+    tsup: "^8.5.0",
+    typescript: "^5.8.2"
+  }
+};
+
+// src/index.ts
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { templates } from "@newt-app/templates";
+
+// src/tasks.ts
+import { execa } from "execa";
+
+// src/utils.ts
+import ejs from "ejs";
+import { existsSync, promises } from "fs";
+import path from "path";
+import { getStaticFilePath } from "@newt-app/templates";
+async function updatePackageJson(destDir, packages, templateData) {
+  for (const pkg of packages) {
+    const renderedPackage = ejs.render(pkg.package, templateData);
+    const packageJsonPath = path.join(destDir, pkg.module, "package.json");
+    let packageJsonContent;
+    try {
+      packageJsonContent = await promises.readFile(packageJsonPath, "utf8");
+    } catch (err) {
+      if (typeof err === "object" && err && err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    const packageJson = JSON.parse(packageJsonContent);
+    const dependencyKey = pkg.dev ? "devDependencies" : "dependencies";
+    if (!packageJson[dependencyKey]) {
+      packageJson[dependencyKey] = {};
+    }
+    packageJson[dependencyKey][renderedPackage] = pkg.version;
+    await promises.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2)
+    );
+  }
+}
+async function updateScripts(destDir, scripts, templateData) {
+  for (const script of scripts) {
+    const renderedScript = ejs.render(script.script, templateData);
+    const packageJsonPath = path.join(destDir, script.module, "package.json");
+    let packageJsonContent;
+    try {
+      packageJsonContent = await promises.readFile(packageJsonPath, "utf8");
+    } catch (err) {
+      if (typeof err === "object" && err && err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    const packageJson = JSON.parse(packageJsonContent);
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    packageJson.scripts[script.name] = renderedScript;
+    await promises.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2)
+    );
+  }
+}
+async function renderTemplatesToDisk(basePackages, destDir, templateData) {
+  await promises.mkdir(destDir, { recursive: true });
+  await basePackages.reduce(async (prev, pkg) => {
+    await prev;
+    for (const template of pkg.templates) {
+      try {
+        const destPath = path.join(destDir, template.filename);
+        const destDirPath = path.dirname(destPath);
+        await promises.mkdir(destDirPath, { recursive: true });
+        const output = await ejs.render(template.template, templateData);
+        await promises.writeFile(destPath, output, "utf8");
+      } catch (error) {
+        console.error(`Failed to create ${template.filename}: ${error}`);
+      }
+    }
+    if (pkg.staticFiles) {
+      pkg.staticFiles.reduce(async (prev2, staticFile) => {
+        try {
+          await prev2;
+          const destPath = path.join(destDir, staticFile.filename);
+          const destDirPath = path.dirname(destPath);
+          await promises.mkdir(destDirPath, { recursive: true });
+          await promises.copyFile(getStaticFilePath(staticFile.src), destPath);
+        } catch (e) {
+          console.log(e);
+        }
+      }, Promise.resolve());
+    }
+  }, Promise.resolve());
+}
+function validateProjectName(projectName) {
+  if (!projectName) {
+    return { valid: false, error: "Project name is required" };
+  }
+  if (projectName.length < 1) {
+    return {
+      valid: false,
+      error: "Project name must be at least 1 character long"
+    };
+  }
+  if (projectName.length > 214) {
+    return {
+      valid: false,
+      error: "Project name must be less than 214 characters"
+    };
+  }
+  const invalidChars = /[<>:"/\\|?*]/;
+  if (invalidChars.test(projectName)) {
+    return { valid: false, error: "Project name contains invalid characters" };
+  }
+  const targetPath = path.resolve(process.cwd(), projectName);
+  if (existsSync(targetPath)) {
+    return { valid: false, error: `Directory "${projectName}" already exists` };
+  }
+  return { valid: true };
+}
+
+// src/tasks.ts
+async function scaffold(modules, options) {
+  const validation = validateProjectName(options.name);
+  if (!validation.valid) {
+    console.error(`Error: ${validation.error}`);
+    process.exit(1);
+  }
+  const templateData = {
+    projectName: options.name
+  };
+  await renderTemplatesToDisk(modules, options.name, templateData);
+  const packages = modules.map((mod) => mod.packages).filter((ele) => ele !== void 0).flat();
+  if (packages.length > 0) {
+    await updatePackageJson(options.name, packages, templateData);
+  }
+  const scripts = modules.map((mod) => mod.scripts).filter((ele) => ele !== void 0).flat();
+  if (scripts.length > 0) {
+    await updateScripts(options.name, scripts, templateData);
+  }
+}
+async function pnpmInstall(cwd) {
+  return await execa("pnpm", ["install"], {
+    cwd
+  });
+}
+async function pnpmFormat(cwd) {
+  return await execa("pnpm", ["format"], {
+    cwd
+  });
+}
+async function initGit(cwd) {
+  await execa("git", ["init"], {
+    cwd
+  });
+  await execa("git", ["add", "."], {
+    cwd
+  });
+  await execa("git", ["commit", "-m", "Initial commit"], {
+    cwd
+  });
+}
+
+// src/index.ts
+var TaskBuilder = class {
+  tasks = [];
+  add(task) {
+    this.tasks.push(task);
+  }
+};
+async function doInit(options) {
+  const groupOpts = {
+    ...!options.name && {
+      name: () => p.text({
+        message: "What is your project name?",
+        placeholder: "my-newt-app",
+        validate: (value) => {
+          if (!value) return "Project name is required";
+          if (value.length > 214) return "Project name is too long";
+          if (/[<>:"/\\|?*]/.test(value)) return "Project name contains invalid characters";
+        }
+      })
+    }
+  };
+  try {
+    const group2 = await p.group(groupOpts, {
+      onCancel: () => {
+        console.log("Exiting.");
+        process.exit(0);
+      }
+    });
+    const allModules = [
+      templates.root,
+      templates.web,
+      templates.api,
+      templates.auth,
+      templates.ui,
+      templates.eslintConfig,
+      templates.typescriptConfig
+    ];
+    const name = group2.name ?? options.name ?? "";
+    const taskBuilder = new TaskBuilder();
+    taskBuilder.add({
+      title: "Scaffolding project",
+      task: async () => {
+        try {
+          await scaffold(allModules, { name });
+        } catch (e) {
+          console.log(e);
+        }
+        return "Scaffolded.";
+      }
+    });
+    if (options.install) {
+      taskBuilder.add({
+        title: "Installing with pnpm",
+        task: async () => {
+          try {
+            await pnpmInstall(name);
+          } catch (e) {
+            console.log(e);
+          }
+          return "Installed.";
+        }
+      });
+      taskBuilder.add({
+        title: "Formatting",
+        task: async () => {
+          await pnpmFormat(name);
+          return "Formatted.";
+        }
+      });
+    }
+    if (options.git) {
+      taskBuilder.add({
+        title: "Initializing git",
+        task: async () => {
+          await initGit(name);
+          return "Initialized git.";
+        }
+      });
+    }
+    await p.tasks(taskBuilder.tasks);
+    p.outro(`Done!`);
+    console.log("Next steps:");
+    console.log();
+    console.log(chalk.blue(`  cd ${name}`));
+    console.log(chalk.blue(`  cp .env.example .env`));
+    console.log(chalk.blue(`  # fill in DATABASE_URL`));
+    console.log(chalk.blue(`  pnpm db:migrate`));
+    console.log(chalk.blue(`  pnpm dev`));
+    console.log();
+  } catch (error) {
+    console.error(
+      `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    process.exit(1);
+  }
+}
+var program = new Command();
+program.name("create-newt-app").version(package_default.version).description("Create a new newt-app monorepo").argument("[name]").option("-ni, --no-install", "Skip pnpm install", true).option("-ng, --no-git", "Skip git initialization", true).action(
+  async (name, options) => {
+    console.log("\n");
+    intro(`Create a ${chalk.blue("newt")} app.`);
+    await doInit({
+      name,
+      install: options.install,
+      git: options.git
+    });
+  }
+);
+program.parse();
+export {
+  doInit
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "create-newt-app",
+  "version": "0.0.2",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "create-newt-app": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ejs": "^3.1.10",
+    "execa": "^9.6.0",
+    "zod": "^3.25.76",
+    "@newt-app/templates": "0.0.2"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}