boilercraft 1.0.0 → 1.1.0

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "boilercraft",
-  "version": "1.0.0",
-  "description": "Create Laravel, Next.js, Express and .NET projects with the official tooling — any version, auth, themes. Run: npx boilercraft",
+  "version": "1.1.0",
+  "description": "Create Laravel, Next.js, NestJS, Vite, Django, FastAPI, Go, Express and .NET projects with the official tooling — any version, auth, themes, Docker, CI. Run: npx boilercraft",
   "main": "main.js",
   "scripts": {
     "start": "node server.js",
     "desktop": "electron .",
     "dev": "node server.js",
     "build:exe": "electron-builder --win portable",
-    "cli": "node bin/boilercraft.js"
+    "cli": "node bin/boilercraft.js",
+    "test": "node --test test/engine.test.js test/extras.test.js test/cli-services.test.js"
   },
   "build": {
     "appId": "com.argrabbi.boilercraft",
@@ -41,7 +42,19 @@
     "cli",
     "scaffold",
     "create-app",
-    "npx"
+    "npx",
+    "nestjs",
+    "vite",
+    "react",
+    "vue",
+    "svelte",
+    "django",
+    "fastapi",
+    "python",
+    "go",
+    "gin",
+    "docker",
+    "prisma"
   ],
   "author": "ARG RABBI",
   "license": "MIT",
@@ -73,7 +86,6 @@
     "stacks/",
     "templates/",
     "public/",
-    "docs/",
     "server.js",
     "README.md",
     "LICENSE"

package/public/index.html

@@ -530,6 +530,7 @@
         const { stacks } = await res.json();
         for (const stack of stacks) {
           stackCatalog[stack.id] = stack;
+          addBackendCard(stack);
           const select = document.getElementById(VERSION_SELECTS[stack.id]);
           if (!select) continue;
           select.innerHTML = '';
@@ -552,6 +553,26 @@
       updateSummary();
     }
 
+    // Stacks without a hand-made card above (NestJS, Vite, Django, FastAPI, Go …)
+    // get one from their manifest, so a new stack shows up here with no HTML change.
+    function addBackendCard(stack) {
+      const grid = document.getElementById('backendOptions');
+      if (grid.querySelector(`[data-stack="${stack.id}"]`)) return;
+      if ([...grid.querySelectorAll('.choice-card')].some(c => (c.getAttribute('onclick') || '').includes(`'${stack.id}'`))) return;
+      const card = document.createElement('div');
+      card.className = 'choice-card';
+      card.dataset.stack = stack.id;
+      card.onclick = () => selectBackend(stack.id, card);
+      const title = document.createElement('div');
+      title.className = 'choice-title';
+      title.textContent = stack.name;
+      const desc = document.createElement('div');
+      desc.className = 'choice-desc';
+      desc.textContent = stack.description || '';
+      card.append(title, desc);
+      grid.appendChild(card);
+    }
+
     function renderEngineNote() {
       const note = document.getElementById('engineNote');
       const stack = stackCatalog[state.backend];
@@ -645,7 +666,10 @@
         port: parseInt(document.getElementById('serverPort').value),
         backend: state.backend,
         stack: state.backend,
-        database: state.database,
+        // Stacks like Vite or Go have their own database list (e.g. only 'none').
+        database: stackCatalog[state.backend] && !stackCatalog[state.backend].databases.includes(state.database)
+          ? stackCatalog[state.backend].databases[0]
+          : state.database,
         styling: state.styling,
         // Keyed by stack id; values are major versions ("12", "16", …).
         versions: {

package/server.js

@@ -1,7 +1,9 @@
 const express = require('express');
 const cors = require('cors');
 const path = require('path');
-const { generateProject } = require('./services/projectGenerator');
+// Every stack now goes through services/generate.js (manifest engine, with the
+// template generator only as an offline fallback), so this direct import is unused.
+// const { generateProject } = require('./services/projectGenerator');
 const { getLatestNpmVersion, getLatestPackagistVersion } = require('./services/versionResolver');
 const { describeStacks, RequirementError } = require('./services/engine/scaffoldEngine');
 // generate() (engine + legacy fallback) lives in services/generate.js, shared with the CLI.

package/services/engine/extras.js

@@ -0,0 +1,354 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Optional add-ons that work across stacks: Docker, GitHub Actions CI,
+ * ESLint + Prettier and Prisma. A manifest opts in with
+ *
+ *   "runtime": "node" | "php" | "dotnet" | "python" | "go",
+ *   "extras": ["docker", "ci", "lint", "prisma"],
+ *   "docker": { "build": "npm run build", "start": "npm start" },
+ *   "ci": { "test": "php artisan test" }
+ *
+ * Files are generated from the runtime, so a new stack gets all of this by
+ * declaring three fields instead of copying templates around.
+ */
+
+const EXTRAS = {
+  docker: { label: 'Docker', hint: 'Dockerfile + docker-compose with your database' },
+  ci: { label: 'GitHub Actions CI', hint: 'build + test on every push' },
+  lint: { label: 'ESLint + Prettier', hint: 'lint and format scripts' },
+  prisma: { label: 'Prisma ORM', hint: 'schema, client and migrations' }
+};
+
+function supportedExtras(stack) {
+  return (stack.extras || []).filter(x => EXTRAS[x]);
+}
+
+const write = (dir, rel, content) => {
+  const file = path.join(dir, rel);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content.replace(/^\n/, ''));
+};
+
+// ---------------------------------------------------------------------------
+// Docker
+// ---------------------------------------------------------------------------
+
+function dockerfile(stack, ctx) {
+  const port = ctx.vars.PORT;
+  const d = stack.docker || {};
+  const cmd = JSON.stringify((d.start || '').split(' ').filter(Boolean));
+  switch (stack.runtime) {
+    case 'node':
+      return `
+FROM node:22-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+${d.build ? `RUN ${d.build}\n` : ''}ENV PORT=${port}
+EXPOSE ${port}
+CMD ${cmd}
+`;
+    case 'php':
+      return `
+FROM php:8.3-cli
+RUN apt-get update && apt-get install -y git unzip libzip-dev \\
+ && docker-php-ext-install pdo pdo_mysql zip && rm -rf /var/lib/apt/lists/*
+COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
+WORKDIR /app
+COPY . .
+${fs.existsSync(path.join(ctx.projectDir, 'composer.json')) ? 'RUN composer install --no-dev --optimize-autoloader --no-interaction\n' : ''}EXPOSE ${port}
+CMD ${cmd}
+`;
+    case 'dotnet':
+      return `
+FROM mcr.microsoft.com/dotnet/sdk:${ctx.major}.0 AS build
+WORKDIR /src
+COPY . .
+RUN dotnet publish -c Release -o /out
+
+FROM mcr.microsoft.com/dotnet/aspnet:${ctx.major}.0
+WORKDIR /app
+COPY --from=build /out .
+ENV ASPNETCORE_URLS=http://+:${port}
+EXPOSE ${port}
+ENTRYPOINT ["dotnet", "${ctx.name}.dll"]
+`;
+    case 'python':
+      return `
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE ${port}
+CMD ${cmd}
+`;
+    case 'go':
+      return `
+FROM golang:1-alpine AS build
+WORKDIR /src
+COPY go.* ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 go build -o /app .
+
+FROM alpine:3
+COPY --from=build /app /app
+COPY --from=build /src/public /public
+WORKDIR /
+ENV PORT=${port}
+EXPOSE ${port}
+ENTRYPOINT ["/app"]
+`;
+    default:
+      return null;
+  }
+}
+
+const DB_SERVICES = {
+  mysql: name => `
+  db:
+    image: mysql:8
+    environment:
+      MYSQL_DATABASE: ${name}
+      MYSQL_ALLOW_EMPTY_PASSWORD: "yes"
+    ports: ["3306:3306"]
+    volumes: [db-data:/var/lib/mysql]
+`,
+  postgresql: name => `
+  db:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: ${name}
+      POSTGRES_PASSWORD: postgres
+    ports: ["5432:5432"]
+    volumes: [db-data:/var/lib/postgresql/data]
+`,
+  mongodb: () => `
+  db:
+    image: mongo:7
+    ports: ["27017:27017"]
+    volumes: [db-data:/data/db]
+`,
+  mssql: () => `
+  db:
+    image: mcr.microsoft.com/mssql/server:2022-latest
+    environment:
+      ACCEPT_EULA: "Y"
+      MSSQL_SA_PASSWORD: \${DB_PASSWORD:-Change_me_123}
+    ports: ["1433:1433"]
+    volumes: [db-data:/var/opt/mssql]
+`
+};
+
+function applyDocker(stack, ctx) {
+  const file = dockerfile(stack, ctx);
+  if (!file) return ctx.warn(`Docker: no Dockerfile recipe for runtime '${stack.runtime}'`);
+  const { projectDir, vars, database } = ctx;
+  write(projectDir, 'Dockerfile', file);
+  write(projectDir, '.dockerignore', `
+node_modules
+vendor
+bin
+obj
+.venv
+__pycache__
+.git
+.env
+`);
+  const db = DB_SERVICES[database];
+  write(projectDir, 'docker-compose.yml', `
+services:
+  app:
+    build: .
+    ports: ["${vars.PORT}:${vars.PORT}"]
+    env_file:
+      - path: .env
+        required: false
+${db ? '    environment:\n      DB_HOST: db\n    depends_on: [db]\n' : ''}${db ? db(vars.DB_NAME) : ''}${db ? '\nvolumes:\n  db-data:\n' : ''}`);
+  ctx.log('Added Dockerfile and docker-compose.yml');
+}
+
+// ---------------------------------------------------------------------------
+// GitHub Actions
+// ---------------------------------------------------------------------------
+
+function ciSteps(stack, ctx) {
+  const test = stack.ci?.test;
+  switch (stack.runtime) {
+    case 'node':
+      return `
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+      - run: npm ci
+      - run: npm run lint --if-present
+      - run: npm run build --if-present
+      - run: ${test || 'npm test --if-present'}`;
+    case 'php':
+      return `
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.3'
+${fs.existsSync(path.join(ctx.projectDir, 'composer.json')) ? '      - run: composer install --no-interaction --prefer-dist\n' : ''}      - run: ${test || 'find . -name "*.php" -not -path "./vendor/*" -print0 | xargs -0 -n1 php -l'}`;
+    case 'dotnet':
+      return `
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '${ctx.major}.0.x'
+      - run: dotnet build
+      - run: ${test || 'dotnet test --no-build'}`;
+    case 'python':
+      return `
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: pip install -r requirements.txt
+      - run: ${test || 'python -m compileall -q .'}`;
+    case 'go':
+      return `
+      - uses: actions/setup-go@v5
+        with:
+          go-version: stable
+      - run: go vet ./...
+      - run: go build ./...
+      - run: ${test || 'go test ./...'}`;
+    default:
+      return null;
+  }
+}
+
+function applyCi(stack, ctx) {
+  const steps = ciSteps(stack, ctx);
+  if (!steps) return ctx.warn(`CI: no workflow recipe for runtime '${stack.runtime}'`);
+  write(ctx.projectDir, '.github/workflows/ci.yml', `
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4${steps}
+`);
+  ctx.log('Added GitHub Actions workflow');
+}
+
+// ---------------------------------------------------------------------------
+// ESLint + Prettier (Node stacks)
+// ---------------------------------------------------------------------------
+
+function readPkg(dir) {
+  const file = path.join(dir, 'package.json');
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+}
+
+function mergeScripts(dir, scripts) {
+  const pkg = readPkg(dir);
+  if (!pkg) return;
+  pkg.scripts = { ...scripts, ...pkg.scripts }; // never clobber the framework's own scripts
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+}
+
+async function applyLint(stack, ctx, { runCommand }) {
+  const { projectDir } = ctx;
+  const pkg = readPkg(projectDir);
+  if (!pkg) return ctx.warn('ESLint + Prettier: no package.json, skipped');
+  const hasEslint = !!(pkg.devDependencies?.eslint || pkg.dependencies?.eslint);
+
+  ctx.log('Adding ESLint + Prettier');
+  const deps = ['prettier', 'eslint-config-prettier'];
+  if (!hasEslint) deps.push('eslint', '@eslint/js', 'globals');
+  await runCommand('npm', ['install', '-D', ...deps], projectDir, ctx.log);
+
+  if (!hasEslint && pkg.type === 'module') {
+    write(projectDir, 'eslint.config.js', `
+import js from '@eslint/js';
+import globals from 'globals';
+import prettier from 'eslint-config-prettier';
+
+export default [
+  { ignores: ['node_modules/', 'dist/'] },
+  js.configs.recommended,
+  { languageOptions: { ecmaVersion: 'latest', sourceType: 'module', globals: { ...globals.browser, ...globals.node } } },
+  prettier
+];
+`);
+  } else if (!hasEslint) {
+    write(projectDir, 'eslint.config.js', `
+const js = require('@eslint/js');
+const globals = require('globals');
+const prettier = require('eslint-config-prettier');
+
+module.exports = [
+  { ignores: ['node_modules/', 'dist/', 'public/'] },
+  js.configs.recommended,
+  { languageOptions: { ecmaVersion: 'latest', sourceType: 'commonjs', globals: globals.node } },
+  prettier
+];
+`);
+  }
+  write(projectDir, '.prettierrc', '{\n  "singleQuote": true,\n  "semi": true,\n  "printWidth": 100\n}\n');
+  write(projectDir, '.prettierignore', 'node_modules\ndist\n.next\nbuild\n');
+  mergeScripts(projectDir, { lint: 'eslint .', format: 'prettier --write .' });
+}
+
+// ---------------------------------------------------------------------------
+// Prisma (Node stacks)
+// ---------------------------------------------------------------------------
+
+const PRISMA_PROVIDERS = { mysql: 'mysql', postgresql: 'postgresql', mssql: 'sqlserver', mongodb: 'mongodb', sqlite: 'sqlite' };
+
+function prismaUrl(database, db) {
+  return {
+    mysql: `mysql://root:@127.0.0.1:3306/${db}`,
+    postgresql: `postgresql://postgres:postgres@127.0.0.1:5432/${db}`,
+    mssql: `sqlserver://127.0.0.1:1433;database=${db};user=sa;password=change-me;trustServerCertificate=true`,
+    mongodb: `mongodb://127.0.0.1:27017/${db}`,
+    sqlite: 'file:./dev.db'
+  }[database];
+}
+
+async function applyPrisma(stack, ctx, { runCommand }) {
+  const provider = PRISMA_PROVIDERS[ctx.database];
+  if (!provider) return ctx.warn(`Prisma: database '${ctx.database}' is not supported, skipped`);
+  const { projectDir } = ctx;
+  ctx.log('Adding Prisma ORM');
+  await runCommand('npm', ['install', '-D', 'prisma@6'], projectDir, ctx.log);
+  await runCommand('npm', ['install', '@prisma/client@6'], projectDir, ctx.log);
+  await runCommand('npx', ['prisma', 'init', '--datasource-provider', provider], projectDir, ctx.log);
+
+  const url = `DATABASE_URL="${prismaUrl(ctx.database, ctx.vars.DB_NAME)}"`;
+  for (const f of ['.env', '.env.local']) {
+    const file = path.join(projectDir, f);
+    if (!fs.existsSync(file)) continue;
+    const content = fs.readFileSync(file, 'utf8');
+    fs.writeFileSync(file, /^DATABASE_URL=.*$/m.test(content) ? content.replace(/^DATABASE_URL=.*$/m, url) : content.replace(/\s*$/, `\n${url}\n`));
+  }
+  mergeScripts(projectDir, { 'db:migrate': 'prisma migrate dev', 'db:studio': 'prisma studio' });
+}
+
+// ---------------------------------------------------------------------------
+
+async function applyExtras(ctx, helpers) {
+  const { stack } = ctx;
+  for (const extra of ctx.extras || []) {
+    try {
+      if (extra === 'docker') applyDocker(stack, ctx);
+      else if (extra === 'ci') applyCi(stack, ctx);
+      else if (extra === 'lint') await applyLint(stack, ctx, helpers);
+      else if (extra === 'prisma') await applyPrisma(stack, ctx, helpers);
+    } catch (err) {
+      ctx.warn(`${EXTRAS[extra].label} failed: ${err.message.split('\n')[0]}`);
+    }
+  }
+}
+
+module.exports = { EXTRAS, supportedExtras, applyExtras, dockerfile };

package/services/engine/postCreate.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Leaves the project as a git repository with one clean commit. Some official
+ * creators (create-next-app, nest new) already run `git init` and commit their
+ * own files; then only BoilerCraft's additions are committed on top.
+ * Never fails the scaffold — a missing git or identity just becomes a warning.
+ */
+async function initGit(ctx, capture) {
+  const { projectDir, log, warn } = ctx;
+  const git = (...args) => capture('git', args, projectDir);
+
+  if (!(await git('--version')).ok) return warn('git not found — skipped repository setup');
+
+  const fresh = !fs.existsSync(path.join(projectDir, '.git'));
+  if (fresh) {
+    const init = await git('init', '-b', 'main');
+    if (!init.ok && !(await git('init')).ok) return warn('git init failed — skipped repository setup');
+  }
+  await git('add', '-A');
+  if (!(await git('status', '--porcelain')).out.trim()) return log('Git repository ready');
+
+  const message = fresh ? 'Initial commit from BoilerCraft' : 'Add BoilerCraft auth, database and theme';
+  const commit = await git('commit', '-q', '-m', message);
+  if (commit.ok) return log(fresh ? 'Initialized git repository' : 'Committed BoilerCraft files');
+  warn('git commit failed (set user.name / user.email), files are staged — commit them yourself');
+}
+
+module.exports = { initGit };

package/services/engine/scaffoldEngine.js

@@ -4,6 +4,8 @@ const crypto = require('crypto');
 const { spawn } = require('child_process');
 const { listVersions, majorOf } = require('./versionCatalog');
 const { toolEnv } = require('./toolInstaller');
+const { applyExtras, supportedExtras } = require('./extras');
+const { initGit } = require('./postCreate');
 const { generateThemeCSS, getThemeSwitcherJS } = require('../themeGenerator');
 const { generateDynamicStackReadme } = require('../readmeGenerator');
 const {
@@ -31,7 +33,8 @@ const {
  * needs one more overlay folder + a `when: { version: ">=N" }` step.
  */
 
-const STACKS_DIR = path.join(__dirname, '..', '..', 'stacks');
+// BOILERCRAFT_STACKS_DIR lets tests point the engine at fixture stacks.
+const STACKS_DIR = process.env.BOILERCRAFT_STACKS_DIR || path.join(__dirname, '..', '..', 'stacks');
 
 class RequirementError extends Error {
   constructor(missing) {
@@ -52,7 +55,8 @@ function loadStacks() {
     .map(dir => {
       const manifest = JSON.parse(fs.readFileSync(path.join(STACKS_DIR, dir, 'stack.json'), 'utf8'));
       return { ...manifest, id: manifest.id || dir, dir: path.join(STACKS_DIR, dir) };
-    });
+    })
+    .sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
 }
 
 function getStack(id) {
@@ -96,6 +100,7 @@ function matches(when, ctx) {
   if (when.auth !== undefined && when.auth !== ctx.auth) return false;
   if (when.roles !== undefined && when.roles !== ctx.roles) return false;
   if (when.platform !== undefined && !oneOf(when.platform, process.platform)) return false;
+  if (when.extra !== undefined && !(ctx.extras || []).includes(when.extra)) return false;
   // Any other key refers to a stack-specific option (e.g. Next.js "router").
   for (const [key, expected] of Object.entries(when)) {
     if (BUILTIN_WHEN_KEYS.has(key)) continue;
@@ -104,7 +109,7 @@ function matches(when, ctx) {
   return true;
 }
 
-const BUILTIN_WHEN_KEYS = new Set(['version', 'database', 'styling', 'auth', 'roles', 'platform']);
+const BUILTIN_WHEN_KEYS = new Set(['version', 'database', 'styling', 'auth', 'roles', 'platform', 'extra']);
 
 // Stack-specific options (manifest "options"), validated, with defaults filled in.
 function resolveOptions(stack, given = {}) {
@@ -190,7 +195,9 @@ function buildVars(config, stack, ctx) {
   const dbEnv = password => ({
     mongodb: `MONGODB_URI=mongodb://127.0.0.1:27017/${vars.DB_NAME}`,
     mysql: `DB_HOST=127.0.0.1\nDB_PORT=3306\nDB_DATABASE=${vars.DB_NAME}\nDB_USERNAME=root\nDB_PASSWORD=`,
-    mssql: `DB_HOST=127.0.0.1\nDB_PORT=1433\nDB_DATABASE=${vars.DB_NAME}\nDB_USERNAME=sa\nDB_PASSWORD=${password}`
+    mssql: `DB_HOST=127.0.0.1\nDB_PORT=1433\nDB_DATABASE=${vars.DB_NAME}\nDB_USERNAME=sa\nDB_PASSWORD=${password}`,
+    postgresql: `DB_HOST=127.0.0.1\nDB_PORT=5432\nDB_DATABASE=${vars.DB_NAME}\nDB_USERNAME=postgres\nDB_PASSWORD=${password}`,
+    sqlite: 'DB_PATH=database.sqlite'
   }[ctx.database] || '');
   // Stack options are available as {{OPTION_<ID>}}, e.g. {{OPTION_FRONTEND}}.
   for (const [id, value] of Object.entries(ctx.options || {})) vars[`OPTION_${id.toUpperCase()}`] = String(value);
@@ -253,7 +260,8 @@ function runCommand(cmd, args, cwd, log, extraEnv = {}) {
     const child = spawn(line, {
       cwd,
       shell: true,
-      env: { ...toolEnv(), CI: '1', COMPOSER_NO_INTERACTION: '1', DOTNET_CLI_TELEMETRY_OPTOUT: '1', DOTNET_NOLOGO: '1', ...extraEnv }
+      stdio: ['ignore', 'pipe', 'pipe'], // no stdin: a tool that prompts gets EOF instead of hanging
+      env: { ...toolEnv(), CI: '1', COMPOSER_NO_INTERACTION: '1', DOTNET_CLI_TELEMETRY_OPTOUT: '1', DOTNET_NOLOGO: '1', CHECKPOINT_DISABLE: '1', ...extraEnv }
     });
     let tail = '';
     const onData = chunk => {
@@ -272,8 +280,12 @@ function runCommand(cmd, args, cwd, log, extraEnv = {}) {
 }
 
 function captureCommand(cmd, args) {
+  return captureIn(cmd, args);
+}
+
+function captureIn(cmd, args, cwd) {
   return new Promise(resolve => {
-    const child = spawn([cmd, ...args].map(quoteArg).join(' '), { shell: true, env: toolEnv() });
+    const child = spawn([cmd, ...args].map(quoteArg).join(' '), { shell: true, cwd, env: toolEnv() });
     let out = '';
     child.stdout.on('data', c => (out += c));
     child.stderr.on('data', c => (out += c));
@@ -325,6 +337,7 @@ async function executeStep(step, ctx) {
     copyDir(path.join(stack.dir, step.copy), step.to ? resolvePath(step.to) : projectDir, vars, log);
   } else if (step.write) {
     const file = resolvePath(step.write);
+    if (step.ifMissing && fs.existsSync(file)) return;
     ensureDir(path.dirname(file));
     fs.writeFileSync(file, interpolate(readSource(step), vars));
   } else if (step.prepend) {
@@ -334,6 +347,7 @@ async function executeStep(step, ctx) {
   } else if (step.append) {
     const file = resolvePath(step.append);
     if (!fs.existsSync(file)) return warn(`append: ${step.append} not found, skipped`);
+    if (step.skipIfContains && fs.readFileSync(file, 'utf8').includes(step.skipIfContains)) return;
     fs.appendFileSync(file, interpolate(readSource(step), vars));
   } else if (step.replace) {
     const file = resolvePath(step.replace);
@@ -376,6 +390,7 @@ async function executeStep(step, ctx) {
 async function checkRequirements(stack, major) {
   const missing = [];
   for (const req of stack.requires || []) {
+    if (req.platform && !oneOf(req.platform, process.platform)) continue;
     const { ok, out } = await captureCommand(req.cmd, req.args || ['--version']);
     if (!ok) {
       missing.push({ tool: req.tool || req.cmd, name: req.name || req.cmd, install: req.install, major });
@@ -413,6 +428,10 @@ async function describeStacks() {
       databases: stack.databases,
       options: stack.options || [],
       stylings: stack.stylings,
+      extras: supportedExtras(stack),
+      auth: stack.auth !== false,
+      description: stack.description || '',
+      nextSteps: stack.nextSteps || [],
       versions,
       requirements: { ok: missing.length === 0, missing }
     };
@@ -467,9 +486,10 @@ async function scaffold(config, outputBasePath = null, onLog = () => {}) {
     major,
     database,
     styling,
-    auth: config.auth ? config.auth.enabled !== false : true,
+    auth: stack.auth === false ? false : config.auth ? config.auth.enabled !== false : true,
     roles: !!config.auth?.roles,
     options: resolveOptions(stack, config.options),
+    extras: (config.extras || []).filter(x => supportedExtras(stack).includes(x)),
     parentDir,
     projectDir,
     log,
@@ -491,6 +511,9 @@ async function scaffold(config, outputBasePath = null, onLog = () => {}) {
     );
   }
 
+  await applyExtras(ctx, { runCommand, interpolate });
+  if (config.git !== false) await initGit(ctx, captureIn);
+
   log('Done.');
   return {
     success: true,
@@ -498,7 +521,7 @@ async function scaffold(config, outputBasePath = null, onLog = () => {}) {
     projectName: name,
     path: projectDir,
     version: major,
-    combination: [`${stack.id}@${major}`, ...Object.values(ctx.options), database, styling].join(' + '),
+    combination: [`${stack.id}@${major}`, ...Object.values(ctx.options), database, styling, ...ctx.extras].join(' + '),
     nextSteps: (stack.nextSteps || []).map(s => interpolate(s, ctx.vars)),
     warnings,
     logs
@@ -513,5 +536,8 @@ module.exports = {
   loadStacks,
   parseMajor,
   versionMatches,
+  matches,
+  interpolate,
+  resolveOptions,
   RequirementError
 };

package/services/engine/versionCatalog.js

@@ -55,6 +55,22 @@ const sources = {
     return newestPerMajor(releases.map(r => r.version), minMajor);
   },
 
+  async pypi({ package: pkg, minMajor = 0 }) {
+    const res = await axios.get(`https://pypi.org/pypi/${encodeURIComponent(pkg)}/json`, { timeout: 5000 });
+    return newestPerMajor(Object.keys(res.data.releases || {}), minMajor);
+  },
+
+  // Go modules: proxy.golang.org lists every tagged version, one per line.
+  async goproxy({ package: mod, minMajor = 0 }) {
+    const res = await axios.get(`https://proxy.golang.org/${mod.toLowerCase()}/@v/list`, { timeout: 5000, responseType: 'text' });
+    return newestPerMajor(String(res.data).split('\n').filter(Boolean), minMajor);
+  },
+
+  // Stacks with no upstream framework release (e.g. raw PHP) pin their list.
+  async static({ offline = [] }) {
+    return offline.map(major => ({ major, latest: `${major}.x` }));
+  },
+
   async dotnet({ minMajor = 0 }) {
     const res = await axios.get(
       'https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json',

package/services/generate.js

@@ -21,8 +21,8 @@ async function runLegacy(config, warning) {
 }
 
 /**
- * Stacks with a manifest in stacks/ are scaffolded by the official-CLI engine.
- * Everything else (e.g. raw-php) still uses the template generator. If the
+ * Every stack has a manifest in stacks/ and is scaffolded by the engine;
+ * the template generator is only an offline fallback. If the
  * required toolchain is missing, fall back to templates unless the caller
  * opted out with allowLegacyFallback: false.
  */