@nabilabs/create-builder 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nabi Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# @nabilabs/create-builder <a href="https://www.npmjs.com/package/@nabilabs/create-builder"><img src="https://img.shields.io/npm/v/@nabilabs/create-builder" alt="npm package"></a>
+
+## Scaffolding Your First Nabi Builder Project
+
+> **Compatibility Note:**
+> Generated projects require [Node.js](https://nodejs.org/) 22 or later
+
+With npm:
+
+```bash
+npm create @nabilabs/builder@latest
+```
+
+With Yarn:
+
+```bash
+yarn create @nabilabs/builder
+```
+
+With pnpm:
+
+```bash
+pnpm create @nabilabs/builder
+```
+
+With Bun:
+
+```bash
+bun create @nabilabs/builder
+```
+
+Then follow the prompts.
+
+You can specify the project name directly:
+
+```bash
+# npm
+npm create @nabilabs/builder@latest my-site
+
+# Yarn
+yarn create @nabilabs/builder my-site
+
+# pnpm
+pnpm create @nabilabs/builder my-site
+
+# Bun
+bun create @nabilabs/builder my-site
+```
+
+The CLI always creates a two-page default project with `/` and `/about`, shared UI components, colocated styles, and local SVG assets.
+
+Use `.` as the project name to scaffold in the current directory. It is allowed only when the directory is empty or contains only `package.json` and `node_modules`.
+
+## Builder Documentation
+
+For Builder configuration, components, routing, and build modes, see the [Nabi Builder README](https://github.com/nabilabshq/builder#readme).

package/dist/cli.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawn } from "node:child_process";
+import { access, cp, lstat, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/errors.ts
+class CreateBuilderError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CreateBuilderError";
+  }
+}
+
+// src/index.ts
+var templatesDirectory = resolve(dirname(fileURLToPath(import.meta.url)), "../templates");
+var packageManagerVariable = /\{\{packageManager\}\}/g;
+var templateVariable = /\{\{projectName\}\}/g;
+var packageManagerFromUserAgent = (userAgent) => {
+  const invokingUserAgent = userAgent ?? process.env.npm_config_user_agent;
+  if (invokingUserAgent?.startsWith("bun/"))
+    return "bun";
+  if (invokingUserAgent?.startsWith("pnpm/"))
+    return "pnpm";
+  if (invokingUserAgent?.startsWith("yarn/"))
+    return "yarn";
+  if (userAgent === undefined && process.versions.bun)
+    return "bun";
+  return "npm";
+};
+var packageManagerSpecificationFromUserAgent = (packageManager, userAgent) => {
+  const invokingUserAgent = userAgent ?? process.env.npm_config_user_agent;
+  const version = invokingUserAgent?.match(new RegExp(`(?:^|\\s)${packageManager}/([^\\s]+)`))?.[1];
+  const runtimeVersion = packageManager === "bun" ? process.versions.bun : undefined;
+  const resolvedVersion = version ?? runtimeVersion;
+  return resolvedVersion ? `${packageManager}@${resolvedVersion}` : packageManager;
+};
+var isMissing = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
+var validateProjectName = (projectName) => {
+  const name = projectName.trim();
+  if (!name)
+    throw new CreateBuilderError("Project name cannot be empty.");
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(name)) {
+    throw new CreateBuilderError("Project name may only contain letters, numbers, dots, underscores, and hyphens.");
+  }
+  if (name === "." || name === "..")
+    throw new CreateBuilderError("Project name must name a new directory.");
+  return name;
+};
+var getTemplatePath = async (template) => {
+  if (!/^[a-z0-9][a-z0-9-]*$/i.test(template))
+    throw new CreateBuilderError(`Invalid template: ${template}`);
+  const path = resolve(templatesDirectory, template);
+  if (dirname(path) !== templatesDirectory)
+    throw new CreateBuilderError(`Invalid template: ${template}`);
+  try {
+    const stats = await lstat(path);
+    if (!stats.isDirectory())
+      throw new CreateBuilderError(`Template is not a directory: ${template}`);
+  } catch (error) {
+    if (isMissing(error))
+      throw new CreateBuilderError(`Unknown template: ${template}`);
+    throw error;
+  }
+  return path;
+};
+var getTemplateNames = async () => {
+  const entries = await readdir(templatesDirectory, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((first, second) => first.localeCompare(second));
+};
+var validateTargetDirectory = async ({
+  cwd,
+  projectName
+}) => {
+  const directory = resolve(cwd, projectName);
+  if (basename(directory) !== projectName)
+    throw new CreateBuilderError("Project name must not contain a path.");
+  try {
+    await access(directory);
+  } catch (error) {
+    if (isMissing(error))
+      return directory;
+    throw error;
+  }
+  throw new CreateBuilderError(`Directory already exists: ${directory}`);
+};
+var validateCurrentDirectory = async (directory) => {
+  const stats = await lstat(directory);
+  if (!stats.isDirectory())
+    throw new CreateBuilderError(`Current path is not a directory: ${directory}`);
+  const entries = await readdir(directory);
+  let hasPackageManifest = false;
+  for (const entry of entries) {
+    const path = resolve(directory, entry);
+    const entryStats = await lstat(path);
+    if (entry === "package.json" && entryStats.isFile()) {
+      hasPackageManifest = true;
+      continue;
+    }
+    if (entry === "node_modules" && entryStats.isDirectory())
+      continue;
+    throw new CreateBuilderError(`Current directory may only contain package.json and node_modules: ${directory}`);
+  }
+  return hasPackageManifest;
+};
+var resolveProjectTarget = async ({
+  cwd,
+  projectName
+}) => {
+  if (projectName === "." || projectName === "./") {
+    const directory = resolve(cwd);
+    const hasPackageManifest = await validateCurrentDirectory(directory);
+    return {
+      directory,
+      hasPackageManifest,
+      isCurrentDirectory: true,
+      projectName: validateProjectName(basename(directory))
+    };
+  }
+  const name = validateProjectName(projectName);
+  return {
+    directory: await validateTargetDirectory({ cwd, projectName: name }),
+    hasPackageManifest: false,
+    isCurrentDirectory: false,
+    projectName: name
+  };
+};
+var copyTemplate = async ({
+  destination,
+  destinationExists = false,
+  skipPackageManifest = false,
+  source
+}) => {
+  try {
+    if (destinationExists) {
+      const entries = (await readdir(source)).filter((entry) => !skipPackageManifest || entry !== "package.json");
+      await Promise.all(entries.map((entry) => cp(resolve(source, entry), resolve(destination, entry), {
+        errorOnExist: true,
+        force: false,
+        recursive: true
+      })));
+    } else {
+      await cp(source, destination, {
+        errorOnExist: true,
+        force: false,
+        recursive: true
+      });
+    }
+    await rename(resolve(destination, "gitignore"), resolve(destination, ".gitignore"));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+      throw new CreateBuilderError(`Directory already exists: ${destination}`);
+    }
+    throw error;
+  }
+};
+var isManifest = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readPackageManifest = async (path) => {
+  try {
+    const manifest = JSON.parse(await readFile(path, "utf8"));
+    if (!isManifest(manifest))
+      throw new CreateBuilderError(`Invalid package.json: ${path}`);
+    return manifest;
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      throw new CreateBuilderError(`Invalid package.json: ${path}`);
+    throw error;
+  }
+};
+var manifestSection = (manifest, section) => {
+  const value = manifest[section];
+  if (value === undefined)
+    return {};
+  if (!isManifest(value))
+    throw new CreateBuilderError(`Invalid package.json ${section}.`);
+  return value;
+};
+var mergePackageManifest = async ({
+  directory,
+  packageManagerSpecification,
+  projectName,
+  templatePath
+}) => {
+  const path = resolve(directory, "package.json");
+  const [existing, templateManifest] = await Promise.all([
+    readPackageManifest(path),
+    readPackageManifest(resolve(templatePath, "package.json"))
+  ]);
+  const manifest = {
+    ...templateManifest,
+    ...existing,
+    devDependencies: {
+      ...manifestSection(existing, "devDependencies"),
+      ...manifestSection(templateManifest, "devDependencies")
+    },
+    name: projectName,
+    packageManager: packageManagerSpecification,
+    scripts: {
+      ...manifestSection(existing, "scripts"),
+      ...manifestSection(templateManifest, "scripts")
+    }
+  };
+  await writeFile(path, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+};
+var getFiles = async (directory) => {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const paths = await Promise.all(entries.filter((entry) => entry.name !== "node_modules").map(async (entry) => {
+    const path = resolve(directory, entry.name);
+    if (entry.isDirectory())
+      return getFiles(path);
+    return [path];
+  }));
+  return paths.flat();
+};
+var replaceTemplateVariables = async ({
+  directory,
+  packageManagerSpecification,
+  projectName
+}) => {
+  const files = await getFiles(directory);
+  await Promise.all(files.map(async (path) => {
+    const source = await readFile(path, "utf8");
+    const result = source.replace(templateVariable, projectName).replace(packageManagerVariable, packageManagerSpecification);
+    if (result !== source)
+      await writeFile(path, result, "utf8");
+  }));
+};
+var installDependencies = async (directory, packageManager) => {
+  await new Promise((resolve2, reject) => {
+    const child = spawn(packageManager, ["install"], {
+      cwd: directory,
+      shell: process.platform === "win32",
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0)
+        return resolve2();
+      reject(new CreateBuilderError("Dependency installation failed."));
+    });
+  });
+};
+var createProject = async ({
+  cwd = process.cwd(),
+  install = installDependencies,
+  packageManager = "npm",
+  packageManagerSpecification = packageManager,
+  projectName,
+  template = "default"
+}) => {
+  const target = await resolveProjectTarget({ cwd, projectName });
+  const source = await getTemplatePath(template);
+  if (target.hasPackageManifest)
+    await readPackageManifest(resolve(target.directory, "package.json"));
+  await copyTemplate({
+    destination: target.directory,
+    destinationExists: target.isCurrentDirectory,
+    skipPackageManifest: target.hasPackageManifest,
+    source
+  });
+  await replaceTemplateVariables({
+    directory: target.directory,
+    packageManagerSpecification,
+    projectName: target.projectName
+  });
+  if (target.hasPackageManifest) {
+    await mergePackageManifest({
+      directory: target.directory,
+      packageManagerSpecification,
+      projectName: target.projectName,
+      templatePath: source
+    });
+  }
+  await install(target.directory, packageManager);
+  return {
+    directory: target.directory,
+    projectName: target.projectName,
+    template
+  };
+};
+
+// src/cli.ts
+import process2 from "node:process";
+import { createInterface } from "node:readline/promises";
+var usage = `Create a Nabi Builder project
+
+Usage:
+  bun create @nabilabs/builder [project-name]`;
+var promptValue = async (question) => {
+  const prompt = createInterface({
+    input: process2.stdin,
+    output: process2.stdout
+  });
+  const controller = new AbortController;
+  const onInterrupt = () => controller.abort();
+  process2.once("SIGINT", onInterrupt);
+  try {
+    return await prompt.question(question, { signal: controller.signal });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError")
+      return;
+    throw error;
+  } finally {
+    process2.removeListener("SIGINT", onInterrupt);
+    prompt.close();
+  }
+};
+var promptProjectName = async () => promptValue("Project name: ");
+var printSuccess = ({
+  isCurrentDirectory,
+  packageManager,
+  projectName
+}) => {
+  const runDev = packageManager === "yarn" ? "yarn dev" : `${packageManager} run dev`;
+  const nextSteps = isCurrentDirectory ? runDev : `cd ${projectName}
+${runDev}`;
+  console.log(`
+✔ Project created successfully.
+
+Next steps:
+
+${nextSteps}`);
+};
+var run = async () => {
+  const arguments_ = process2.argv.slice(2);
+  if (arguments_.includes("--help") || arguments_.includes("-h"))
+    return console.log(usage);
+  let projectName;
+  for (let index = 0;index < arguments_.length; index += 1) {
+    const argument = arguments_[index];
+    if (argument.startsWith("-") || projectName !== undefined)
+      throw new CreateBuilderError(usage);
+    projectName = argument;
+  }
+  projectName ??= await promptProjectName();
+  if (projectName === undefined)
+    return;
+  const packageManager = packageManagerFromUserAgent();
+  const packageManagerSpecification = packageManagerSpecificationFromUserAgent(packageManager);
+  const project = await createProject({
+    packageManager,
+    packageManagerSpecification,
+    projectName
+  });
+  printSuccess({
+    isCurrentDirectory: projectName === "." || projectName === "./",
+    packageManager,
+    projectName: project.projectName
+  });
+};
+run().catch((error) => {
+  const message = error instanceof Error ? error.message : "Unexpected error while creating the project.";
+  console.error(`
+Error: ${message}`);
+  process2.exitCode = 1;
+});
+export {
+  promptProjectName,
+  printSuccess
+};