@smi-digital/create-smi-app 1.0.1

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "#dist/index.js";

package/dist/index.js

@@ -0,0 +1,633 @@
+// src/modules/greetings.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+import chalkAnimation from "chalk-animation";
+
+// src/modules/common.ts
+var primary1 = "#8e2de2";
+var primary2 = "#ff00d4";
+
+// src/modules/greetings.ts
+var smiGradient = gradient([primary1, primary2]);
+function greet() {
+  return new Promise((resolve) => {
+    const asciiText = figlet.textSync("SMI - Digital", {
+      font: "Slant"
+    });
+    const styledText = smiGradient(asciiText);
+    const anim = chalkAnimation.neon(styledText);
+    setTimeout(() => {
+      anim.stop();
+      setTimeout(() => {
+        resolve();
+      }, 100);
+    }, 2e3);
+  });
+}
+
+// src/modules/questions.ts
+import chalk from "chalk";
+import { confirm, select, input, checkbox } from "@inquirer/prompts";
+
+// src/modules/scaffoldRegistry.ts
+var PROJECT_TYPE_CHOICES = [
+  { value: "monorepo", name: "Monorepo" },
+  { value: "singleProject", name: "Single Project" }
+];
+var TOOL_CHOICES = [
+  { value: "basic", name: "Basic" },
+  { value: "none", name: "None" }
+];
+var SINGLE_PROJECT_FRAMEWORK_CHOICES = [
+  { value: "astro", name: "Astro" },
+  { value: "react", name: "React" },
+  { value: "none", name: "None" }
+];
+var FRONTEND_FRAMEWORK_CHOICES = [
+  { value: "astro", name: "Astro" },
+  { value: "react", name: "React" },
+  { value: "none", name: "None" }
+];
+var BACKEND_FRAMEWORK_CHOICES = [
+  { value: "strapi", name: "Strapi" },
+  { value: "express", name: "Express" },
+  { value: "none", name: "None" }
+];
+var FRAMEWORK_GENERATORS = {
+  astro: {
+    displayName: "Astro",
+    command: "npm",
+    getArgs(directory) {
+      return [
+        "create",
+        "astro@latest",
+        directory,
+        "--",
+        "--template",
+        "minimal",
+        "--install",
+        "--git",
+        "false",
+        "--yes"
+      ];
+    }
+  },
+  strapi: {
+    displayName: "Strapi",
+    command: "npx",
+    getArgs(directory) {
+      return [
+        "create-strapi@latest",
+        directory,
+        "--quickstart",
+        "--skip-cloud",
+        "--typescript",
+        "--no-run"
+      ];
+    }
+  }
+};
+function asFramework(value) {
+  if (value === "astro" || value === "strapi" || value === "react" || value === "express" || value === "none") {
+    return value;
+  }
+  return "none";
+}
+
+// src/modules/integrations.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+async function loadIntegrationConfig(templatesDir, integrationKey) {
+  const configPath = join(
+    templatesDir,
+    "integrations",
+    integrationKey,
+    "integration.config.json"
+  );
+  const rawContent = await readFile(configPath, "utf8");
+  return JSON.parse(rawContent);
+}
+function matchesIntegration(selection, config) {
+  const { match } = config;
+  if (selection.projectType !== match.projectType) {
+    return false;
+  }
+  if (match.framework && selection.framework !== match.framework) {
+    return false;
+  }
+  if (match.frontendFramework && selection.frontendFramework !== match.frontendFramework) {
+    return false;
+  }
+  if (match.backendFramework && selection.backendFramework !== match.backendFramework) {
+    return false;
+  }
+  return true;
+}
+async function getIntegrationForSelection(templatesDir, selection) {
+  const integrationsRoot = join(templatesDir, "integrations");
+  const entries = await readdir(integrationsRoot, { withFileTypes: true });
+  const folders = entries.filter((entry) => entry.isDirectory());
+  const findSequentially = async (index) => {
+    const folder = folders[index];
+    if (!folder) {
+      return void 0;
+    }
+    const config = await loadIntegrationConfig(templatesDir, folder.name);
+    if (matchesIntegration(selection, config)) {
+      return { key: folder.name, config };
+    }
+    return findSequentially(index + 1);
+  };
+  return findSequentially(0);
+}
+
+// src/modules/questions.ts
+var primary12 = chalk.hex(primary1);
+var primary22 = chalk.hex(primary2);
+var smiTheme = {
+  prefix: {
+    idle: primary12("?"),
+    done: primary22("\u2714")
+  },
+  style: {
+    highlight: (text) => primary12(text),
+    answer: (text) => primary22(text)
+  },
+  icon: {
+    cursor: primary12("\u276F")
+  }
+};
+async function askIntegrationInputs(inputConfig, index = 0, answers = {}) {
+  const current = inputConfig[index];
+  if (!current) {
+    return answers;
+  }
+  if (current.type === "confirm") {
+    const confirmConfig = {
+      message: current.message,
+      theme: smiTheme
+    };
+    if (typeof current.default === "boolean") {
+      confirmConfig.default = current.default;
+    }
+    const result2 = await confirm(confirmConfig);
+    return askIntegrationInputs(inputConfig, index + 1, {
+      ...answers,
+      [current.key]: result2
+    });
+  }
+  const inputConfigData = {
+    message: current.message,
+    validate(value) {
+      if (current.required && value.trim().length === 0) {
+        return "This value is required.";
+      }
+      return true;
+    },
+    theme: smiTheme
+  };
+  if (typeof current.default === "string") {
+    inputConfigData.default = current.default;
+  }
+  const result = await input(inputConfigData);
+  return askIntegrationInputs(inputConfig, index + 1, {
+    ...answers,
+    [current.key]: result
+  });
+}
+async function askQuestions(templatesDir) {
+  const projectName = await input({
+    message: "What is the Project Name?",
+    theme: smiTheme
+  });
+  const tools = await checkbox({
+    message: "Which Tools to install?",
+    choices: TOOL_CHOICES,
+    theme: smiTheme
+  });
+  const projectType = await select({
+    message: "What type of Project?",
+    choices: PROJECT_TYPE_CHOICES,
+    theme: smiTheme
+  });
+  let frameworkAnswers;
+  let configureCd = false;
+  let integrationKey;
+  let integrationInputs = {};
+  if (projectType === "singleProject") {
+    const framework = await select({
+      message: "What Framework?",
+      choices: SINGLE_PROJECT_FRAMEWORK_CHOICES,
+      theme: smiTheme
+    });
+    frameworkAnswers = { framework };
+  } else {
+    const frontendFramework = await select({
+      message: "What frontend Framework?",
+      choices: FRONTEND_FRAMEWORK_CHOICES,
+      theme: smiTheme
+    });
+    const backendFramework = await select({
+      message: "What backend Framework?",
+      choices: BACKEND_FRAMEWORK_CHOICES,
+      theme: smiTheme
+    });
+    frameworkAnswers = { frontendFramework, backendFramework };
+    const integration = await getIntegrationForSelection(templatesDir, {
+      projectType,
+      frontendFramework,
+      backendFramework
+    });
+    integrationKey = integration?.key;
+    if (integration?.config.cd) {
+      configureCd = await confirm({
+        message: integration.config.cd.question,
+        theme: smiTheme
+      });
+      if (configureCd) {
+        integrationInputs = await askIntegrationInputs(
+          integration.config.cd.inputs
+        );
+      }
+    }
+  }
+  const confirmation = await confirm({
+    message: "Should the Project be created with the selected Options?",
+    theme: smiTheme
+  });
+  const result = {
+    projectName,
+    projectType,
+    tools,
+    configureCd,
+    integrationInputs,
+    ...frameworkAnswers,
+    confirmation
+  };
+  if (integrationKey) {
+    return {
+      ...result,
+      integrationKey
+    };
+  }
+  return result;
+}
+
+// src/modules/init.ts
+import { fileURLToPath } from "url";
+import { join as join2, dirname } from "path";
+import { access } from "fs/promises";
+async function resolveTemplatesDir(currentDir) {
+  const candidates = [
+    join2(currentDir, "../../templates"),
+    join2(currentDir, "../templates")
+  ];
+  const checks = await Promise.all(
+    candidates.map(async (candidate) => {
+      try {
+        await access(join2(candidate, "base"));
+        return true;
+      } catch {
+        return false;
+      }
+    })
+  );
+  const index = checks.findIndex(Boolean);
+  if (index !== -1) {
+    const templatesPath = candidates[index];
+    if (templatesPath) {
+      return templatesPath;
+    }
+  }
+  throw new Error(
+    `Templates directory not found. Tried: ${candidates.join(", ")}`
+  );
+}
+async function init() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const templatesDir = await resolveTemplatesDir(__dirname);
+  const targetDir = process.cwd();
+  return { targetDir, templatesDir };
+}
+
+// src/modules/createScaffold.ts
+import { access as access2, mkdir as mkdir2 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/modules/scaffoldActions/createTools.ts
+import { cp, readdir as readdir2 } from "fs/promises";
+import { join as join3 } from "path";
+var templateRenameMap = {
+  "env.template": ".env",
+  "gitignore.template": ".gitignore",
+  "prettierignore.template": ".prettierignore",
+  "prettierrc.template": ".prettierrc",
+  "dependency-cruiser.cjs.template": ".dependency-cruiser.cjs"
+};
+function getTargetFileName(sourceName) {
+  if (templateRenameMap[sourceName]) {
+    return templateRenameMap[sourceName];
+  }
+  if (sourceName.endsWith(".template")) {
+    return sourceName.slice(0, -".template".length);
+  }
+  return sourceName;
+}
+async function createTools(tools, targetDir, templatesDir) {
+  if (!tools.includes("basic")) {
+    return;
+  }
+  const baseToolsDir = join3(templatesDir, "base");
+  const huskyDir = join3(templatesDir, ".husky");
+  const entries = await readdir2(baseToolsDir, { withFileTypes: true });
+  await Promise.all(
+    entries.map(
+      (entry) => cp(
+        join3(baseToolsDir, entry.name),
+        join3(targetDir, getTargetFileName(entry.name)),
+        {
+          recursive: true
+        }
+      )
+    )
+  );
+  await cp(huskyDir, join3(targetDir, ".husky"), {
+    recursive: true
+  });
+}
+
+// src/modules/scaffoldActions/progress.ts
+import { spawn } from "child_process";
+import chalk2 from "chalk";
+var primary = chalk2.hex(primary1);
+var accent = chalk2.hex(primary2);
+var muted = chalk2.gray;
+var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function formatDuration(durationMs) {
+  if (durationMs < 1e3) {
+    return `${durationMs}ms`;
+  }
+  return `${(durationMs / 1e3).toFixed(1)}s`;
+}
+async function runStep(label, task) {
+  const start = Date.now();
+  const canAnimate = Boolean(process.stdout.isTTY);
+  let frameIndex = 0;
+  let spinnerTimer;
+  const renderSpinner = () => {
+    const frame = spinnerFrames[frameIndex % spinnerFrames.length];
+    frameIndex += 1;
+    process.stdout.write(`\r${primary(frame)} ${accent(label)}`);
+  };
+  if (canAnimate) {
+    renderSpinner();
+    spinnerTimer = setInterval(() => {
+      renderSpinner();
+    }, 90);
+  } else {
+    console.log(primary("\u25B6"), accent(label));
+  }
+  try {
+    const result = await task();
+    const duration = Date.now() - start;
+    if (spinnerTimer) {
+      clearInterval(spinnerTimer);
+      process.stdout.write("\r\x1B[2K");
+    }
+    console.log(
+      accent("\u2714"),
+      `${label} ${muted(`(${formatDuration(duration)})`)}`
+    );
+    return result;
+  } catch (error) {
+    const duration = Date.now() - start;
+    if (spinnerTimer) {
+      clearInterval(spinnerTimer);
+      process.stdout.write("\r\x1B[2K");
+    }
+    console.error(
+      chalk2.red("\u2716"),
+      `${label} ${muted(`(${formatDuration(duration)})`)}`
+    );
+    throw error;
+  }
+}
+async function runCommandQuiet(command, args, cwd) {
+  await new Promise((resolve, reject) => {
+    let stderr = "";
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", () => {
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      const stderrTail = stderr.trim().split("\n").slice(-12).join("\n");
+      const details = stderrTail ? `
+${stderrTail}` : "";
+      reject(
+        new Error(
+          `Command failed with exit code ${code}: ${command} ${args.join(" ")}${details}`
+        )
+      );
+    });
+  });
+}
+
+// src/modules/scaffoldActions/createApps.ts
+async function createFrameworkApp(projectRoot, target) {
+  const generator = FRAMEWORK_GENERATORS[target.framework];
+  if (!generator) {
+    return;
+  }
+  await runStep(
+    `Creating ${generator.displayName} ${target.label}`,
+    async () => runCommandQuiet(
+      generator.command,
+      generator.getArgs(target.directory),
+      projectRoot
+    )
+  );
+}
+async function createApps(projectRoot, targets) {
+  const runSequentially = async (index) => {
+    const target = targets[index];
+    if (!target) {
+      return;
+    }
+    await createFrameworkApp(projectRoot, target);
+    await runSequentially(index + 1);
+  };
+  await runSequentially(0);
+}
+
+// src/modules/scaffoldActions/createIntegrations.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+function toTemplateToken(key) {
+  const normalized = key.replaceAll(/[^a-zA-Z0-9]+/gv, "_").replaceAll(/^_+|_+$/gv, "").toUpperCase();
+  return `__${normalized}__`;
+}
+function applyTemplateVariables(content, values) {
+  let result = content;
+  for (const [key, value] of Object.entries(values)) {
+    result = result.replaceAll(toTemplateToken(key), String(value));
+  }
+  return result;
+}
+async function copyTemplateFile(sourcePath, targetPath, values) {
+  const rawContent = await readFile2(sourcePath, "utf8");
+  const content = applyTemplateVariables(rawContent, values);
+  await mkdir(dirname2(targetPath), { recursive: true });
+  await writeFile(targetPath, content, "utf8");
+}
+async function createIntegrations(options, projectRoot, templatesDir) {
+  const { projectType } = options;
+  let { integrationKey } = options;
+  if (!integrationKey) {
+    const selection = projectType === "singleProject" ? {
+      projectType,
+      ..."framework" in options && options.framework ? { framework: options.framework } : {}
+    } : {
+      projectType,
+      ..."frontendFramework" in options && options.frontendFramework ? { frontendFramework: options.frontendFramework } : {},
+      ..."backendFramework" in options && options.backendFramework ? { backendFramework: options.backendFramework } : {}
+    };
+    const integration = await getIntegrationForSelection(
+      templatesDir,
+      selection
+    );
+    integrationKey = integration?.key;
+  }
+  if (!integrationKey) {
+    return;
+  }
+  const integrationConfig = await loadIntegrationConfig(
+    templatesDir,
+    integrationKey
+  );
+  const integrationRoot = join4(templatesDir, "integrations", integrationKey);
+  const filesToApply = [integrationConfig.workflows.prValidation];
+  if (options.configureCd && integrationConfig.workflows.deploy) {
+    filesToApply.push(integrationConfig.workflows.deploy);
+  }
+  const applyFile = async (file) => runStep(
+    `Adding ${file.target}`,
+    async () => copyTemplateFile(
+      join4(integrationRoot, file.template),
+      join4(projectRoot, file.target),
+      options.integrationInputs
+    )
+  );
+  const applySequentially = async (index) => {
+    const file = filesToApply[index];
+    if (!file) {
+      return;
+    }
+    await applyFile(file);
+    await applySequentially(index + 1);
+  };
+  await applySequentially(0);
+}
+
+// src/modules/createScaffold.ts
+import chalk3 from "chalk";
+var accent2 = chalk3.hex(primary2);
+function getAppTargets(options) {
+  if (options.projectType === "singleProject") {
+    return [
+      {
+        framework: asFramework(options.framework),
+        directory: ".",
+        label: "project"
+      }
+    ];
+  }
+  return [
+    {
+      framework: asFramework(options.frontendFramework),
+      directory: "frontend",
+      label: "frontend"
+    },
+    {
+      framework: asFramework(options.backendFramework),
+      directory: "backend",
+      label: "backend"
+    }
+  ];
+}
+async function createProjectStructure(options, projectRoot) {
+  if (options.projectType !== "monorepo") {
+    return;
+  }
+  await Promise.all([
+    mkdir2(join5(projectRoot, "backend"), { recursive: true }),
+    mkdir2(join5(projectRoot, "frontend"), { recursive: true })
+  ]);
+}
+async function initializeGitRepository(projectRoot) {
+  const gitDir = join5(projectRoot, ".git");
+  try {
+    await access2(gitDir);
+    return;
+  } catch {
+  }
+  try {
+    await runCommandQuiet("git", ["init"], projectRoot);
+  } catch {
+    console.warn(
+      "Git is not available. Husky hooks will activate after running git init."
+    );
+  }
+}
+async function createScaffold(options, targetDir, templatesDir) {
+  const projectName = options.projectName.trim();
+  if (!projectName) {
+    throw new Error("Project name cannot be empty.");
+  }
+  console.log();
+  const projectRoot = join5(targetDir, projectName);
+  await runStep(
+    "Creating project folder",
+    async () => mkdir2(projectRoot, { recursive: true })
+  );
+  await runStep(
+    "Preparing project structure",
+    async () => createProjectStructure(options, projectRoot)
+  );
+  if (options.tools.includes("basic")) {
+    await runStep(
+      "Initializing Git repository",
+      async () => initializeGitRepository(projectRoot)
+    );
+    await runStep(
+      "Copying base tools",
+      async () => createTools(options.tools, projectRoot, templatesDir)
+    );
+  }
+  await createApps(projectRoot, getAppTargets(options));
+  await createIntegrations(options, projectRoot, templatesDir);
+  console.log(accent2(`\u25C6 Project scaffolded at ${projectRoot}`));
+}
+
+// src/index.ts
+async function main() {
+  const { targetDir, templatesDir } = await init();
+  await greet();
+  const answers = await askQuestions(templatesDir);
+  if (!answers.confirmation) {
+    return;
+  }
+  await createScaffold(answers, targetDir, templatesDir);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@smi-digital/create-smi-app",
+  "version": "1.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "bin": {
+    "create-smi-app": "./bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "imports": {
+    "#src/*": "./src/*",
+    "#dist/*": "./dist/*"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "npx tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --clean",
+    "typecheck": "tsc --noEmit",
+    "prettier": "npx prettier --write .",
+    "lint": "npx eslint .",
+    "prepare": "husky",
+    "knip": "knip",
+    "depcruise": "depcruise . --exclude \"node_modules|dist|.husky|test\"",
+    "depcheck": "npm run knip && npm run depcruise",
+    "check": "npm run depcheck && npm run lint && npm run typecheck",
+    "prepack": "npm run build"
+  },
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "devDependencies": {
+    "@commitlint/cli": "^20.4.4",
+    "@commitlint/config-conventional": "^20.4.4",
+    "@eslint/js": "^10.0.1",
+    "@eslint/json": "^1.1.0",
+    "@types/chalk-animation": "^1.6.3",
+    "@types/node": "^25.5.0",
+    "dependency-cruiser": "^17.3.9",
+    "eslint": "^10.0.3",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-config-xo": "^0.50.0",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "knip": "^5.86.0",
+    "lint-staged": "^16.3.3",
+    "prettier": "3.8.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.57.0"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,mjs,cjs,astro}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md}": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.6.2",
+    "chalk-animation": "^2.0.3",
+    "figlet": "^1.11.0",
+    "gradient-string": "^3.0.0"
+  }
+}

package/templates/.husky/commit-msg

@@ -0,0 +1 @@
+npx --no -- commitlint --edit 

package/templates/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged