create-epinoetics-app 1.0.0

package/bin/create-epinoetics-app.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { run } from '../src/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'));
+
+program
+  .name('create-epinoetics-app')
+  .description('Scaffold a new project from your boilerplate repos')
+  .version(pkg.version)
+  .argument('[project-name]', 'Name of the project to create')
+  .option('-b, --backend <id>',  'Backend to use: api-nest | api-dotnet')
+  .option('-f, --frontend <id>', 'Frontend to use: web-next | web-astro (when available)')
+  .option('--dry-run',           'Preview without cloning anything')
+  .option('--yes',               'Skip confirmation prompt')
+  .parse(process.argv);
+
+const opts = program.opts();
+const [projectName] = program.args;
+
+run({
+  projectName,
+  backend:  opts.backend,
+  frontend: opts.frontend,
+  dryRun:   opts.dryRun  ?? false,
+  yes:      opts.yes     ?? false,
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "create-epinoetics-app",
+  "version": "1.0.0",
+  "description": "Scaffold a new project from your boilerplate repos",
+  "type": "module",
+  "bin": {
+    "create-epinoetics-app": "./bin/create-epinoetics-app.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "dev": "node bin/create-epinoetics-app.js",
+    "test": "node bin/create-epinoetics-app.js --dry-run"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.0",
+    "chalk": "^5.4.1",
+    "commander": "^12.1.0",
+    "simple-git": "^3.27.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/src/cloner.js

@@ -0,0 +1,33 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { resolve, join } from 'path';
+import { simpleGit } from 'simple-git';
+import fs from 'fs';
+
+export async function cloneAll({ projectName, repos }) {
+  const projectDir = resolve(process.cwd(), projectName);
+  const codeDir    = join(projectDir, 'code');
+
+  // Create root + code/ dirs
+  fs.mkdirSync(codeDir, { recursive: true });
+
+  for (const repo of repos) {
+    const dest    = join(codeDir, repo.id);
+    const spinner = p.spinner();
+
+    spinner.start(`Cloning ${chalk.cyan(repo.label)}  ${chalk.dim(repo.url)}`);
+
+    try {
+      await simpleGit().clone(repo.url, dest, ['--depth=1']);
+
+      // Remove the .git folder so the clone becomes plain source,
+      // not a nested git repo inside the new project.
+      fs.rmSync(join(dest, '.git'), { recursive: true, force: true });
+
+      spinner.stop(`${chalk.green('✓')} ${repo.label}  ${chalk.dim(`→ code/${repo.id}`)}`);
+    } catch (err) {
+      spinner.stop(`${chalk.red('✗')} ${repo.label}  ${chalk.dim(err.message)}`);
+      throw new Error(`Failed to clone ${repo.label}: ${err.message}`);
+    }
+  }
+}

package/src/generator.js

@@ -0,0 +1,105 @@
+import { createRequire } from 'module';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import fse from 'fs-extra';
+import { renderTemplate } from './template.js';
+import { mergePackageJson } from './merge.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = resolve(__dirname, '../templates');
+
+export async function generate(config) {
+  const { projectName, framework, include, css, pm } = config;
+  const dest = resolve(process.cwd(), projectName);
+
+  // Guard against overwriting existing directory
+  if (await fse.pathExists(dest)) {
+    throw new Error(`Directory "${projectName}" already exists.`);
+  }
+
+  await fse.ensureDir(dest);
+
+  const ctx = { projectName, framework, include, css, pm };
+
+  // 1. Copy base template (shared across all projects)
+  await copyTemplateDir('base', dest, ctx);
+
+  // 2. Copy framework-specific template
+  await copyTemplateDir(framework, dest, ctx);
+
+  // 3. Apply each selected feature overlay
+  for (const feature of include) {
+    const featureDir = join(TEMPLATES_DIR, 'features', feature);
+    if (await fse.pathExists(featureDir)) {
+      await copyTemplateDir(join('features', feature), dest, ctx);
+    }
+  }
+
+  // 4. Merge all package.json fragments together
+  await buildPackageJson(dest, config);
+
+  // 5. Write scaffold config so the project remembers how it was created
+  await fse.writeJSON(join(dest, 'scaffold.config.json'), {
+    framework,
+    include,
+    css,
+    packageManager: pm,
+    createdAt: new Date().toISOString(),
+  }, { spaces: 2 });
+}
+
+async function copyTemplateDir(templateName, dest, ctx) {
+  const src = join(TEMPLATES_DIR, templateName);
+  if (!(await fse.pathExists(src))) return;
+
+  const entries = await fse.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    // Skip package.json fragments here — merged separately
+    if (entry.name === 'package.fragment.json') continue;
+
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await fse.ensureDir(destPath);
+      await copyTemplateDir(join(templateName, entry.name), destPath, ctx);
+    } else {
+      const raw = await fse.readFile(srcPath, 'utf8');
+      const rendered = renderTemplate(raw, ctx);
+      await fse.outputFile(destPath, rendered, 'utf8');
+    }
+  }
+}
+
+async function buildPackageJson(dest, config) {
+  const { projectName, framework, include, css, pm } = config;
+
+  // Start with base package.json
+  const base = await loadFragment('base', config);
+  const frameworkFrag = await loadFragment(framework, config);
+
+  let merged = mergePackageJson(base, frameworkFrag);
+
+  // Merge CSS fragment if it exists
+  const cssFrag = await loadFragment(`css-${css}`, config);
+  merged = mergePackageJson(merged, cssFrag);
+
+  // Merge each feature's fragment
+  for (const feature of include) {
+    const frag = await loadFragment(join('features', feature), config);
+    merged = mergePackageJson(merged, frag);
+  }
+
+  merged.name = projectName;
+  merged.version = '0.1.0';
+
+  await fse.writeJSON(join(dest, 'package.json'), merged, { spaces: 2 });
+}
+
+async function loadFragment(name, config) {
+  const fragPath = join(TEMPLATES_DIR, name, 'package.fragment.json');
+  if (!(await fse.pathExists(fragPath))) return {};
+  const raw = await fse.readFile(fragPath, 'utf8');
+  return JSON.parse(renderTemplate(raw, config));
+}

package/src/index.js

@@ -0,0 +1,115 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { REPOS } from './repos.js';
+import { cloneAll } from './cloner.js';
+import { writeRootFiles } from './scaffold.js';
+import { validateProjectName } from './utils.js';
+
+export async function run(flags) {
+  console.log('');
+  p.intro(
+    chalk.bgHex('#7c3aed').white(' create-myapp ') +
+    chalk.dim(' assemble your boilerplate')
+  );
+
+  // ── 1. Project name ───────────────────────────────────────────────
+  let projectName = flags.projectName;
+  if (!projectName) {
+    projectName = await p.text({
+      message: 'Project name',
+      placeholder: 'my-app',
+      validate: validateProjectName,
+    });
+    if (p.isCancel(projectName)) return cancel();
+  }
+
+  // ── 2. Backend ────────────────────────────────────────────────────
+  let backendId = flags.backend;
+  if (!backendId) {
+    backendId = await p.select({
+      message: 'Backend',
+      options: REPOS.backend.map(r => ({
+        value: r.id,
+        label: r.label,
+        hint:  r.hint,
+      })),
+    });
+    if (p.isCancel(backendId)) return cancel();
+  }
+
+  // ── 3. Frontend (only shown if repos are registered) ─────────────
+  let frontendId = flags.frontend ?? null;
+  if (REPOS.frontend?.length > 0 && !frontendId) {
+    frontendId = await p.select({
+      message: 'Frontend',
+      options: REPOS.frontend.map(r => ({
+        value: r.id,
+        label: r.label,
+        hint:  r.hint,
+      })),
+    });
+    if (p.isCancel(frontendId)) return cancel();
+  }
+
+  // ── Build the final list of repos to clone ────────────────────────
+  const selected = buildRepoList({ backendId, frontendId });
+
+  // ── Summary ───────────────────────────────────────────────────────
+  console.log('');
+  p.note(
+    selected
+      .map(r => `${chalk.dim(r.id.padEnd(16))} ${chalk.cyan(r.label)}  ${chalk.dim(r.url)}`)
+      .join('\n'),
+    'Repos to clone'
+  );
+
+  if (flags.dryRun) {
+    p.outro(chalk.yellow('Dry run — no files written.'));
+    return;
+  }
+
+  if (!flags.yes) {
+    const confirm = await p.confirm({ message: `Create "${projectName}"?` });
+    if (p.isCancel(confirm) || !confirm) return cancel();
+  }
+
+  // ── Clone ─────────────────────────────────────────────────────────
+  await cloneAll({ projectName, repos: selected });
+
+  // ── Write root files (.gitignore, README) ─────────────────────────
+  await writeRootFiles({ projectName, selected, backendId, frontendId });
+
+  // ── Done ──────────────────────────────────────────────────────────
+  p.outro(
+    chalk.green('Done!') + '\n\n' +
+    `  ${chalk.dim('cd')} ${chalk.cyan(projectName)}`
+  );
+}
+
+function buildRepoList({ backendId, frontendId }) {
+  const list = [];
+
+  // Fixed repos (dashboard — always included)
+  for (const group of Object.values(REPOS)) {
+    for (const repo of group) {
+      if (repo.fixed) list.push(repo);
+    }
+  }
+
+  // Chosen backend
+  const backend = REPOS.backend.find(r => r.id === backendId);
+  if (backend) list.push(backend);
+
+  // Chosen frontend (optional until repos are added)
+  if (frontendId && REPOS.frontend) {
+    const frontend = REPOS.frontend.find(r => r.id === frontendId);
+    if (frontend) list.push(frontend);
+  }
+
+  return list;
+}
+
+function cancel() {
+  p.cancel('Cancelled.');
+  process.exit(0);
+}

package/src/merge.js

@@ -0,0 +1,26 @@
+/**
+ * Deep-merges two package.json objects.
+ * - scripts, dependencies, devDependencies are merged (b wins on conflict)
+ * - arrays are concatenated and de-duped
+ * - scalars: b wins
+ */
+export function mergePackageJson(a = {}, b = {}) {
+  if (!b || Object.keys(b).length === 0) return { ...a };
+
+  const result = { ...a };
+
+  for (const key of Object.keys(b)) {
+    if (key === 'scripts' || key === 'dependencies' || key === 'devDependencies' ||
+        key === 'peerDependencies' || key === 'optionalDependencies') {
+      result[key] = { ...(a[key] ?? {}), ...(b[key] ?? {}) };
+    } else if (Array.isArray(b[key])) {
+      result[key] = [...new Set([...(a[key] ?? []), ...b[key]])];
+    } else if (typeof b[key] === 'object' && b[key] !== null) {
+      result[key] = mergePackageJson(a[key], b[key]);
+    } else {
+      result[key] = b[key];
+    }
+  }
+
+  return result;
+}

package/src/repos.js

@@ -0,0 +1,62 @@
+/**
+ * Registry of all available boilerplate repos.
+ *
+ * To add a new repo (e.g. Astro or Next.js frontend):
+ *   1. Add an entry to the relevant group below.
+ *   2. That's it — the CLI picks it up automatically.
+ *
+ * Fields:
+ *   id       — internal key, used as the folder name under code/
+ *   label    — shown in the prompt
+ *   hint     — shown as a subtitle in the prompt
+ *   url      — GitHub clone URL
+ *   fixed    — if true, always included (no prompt)
+ */
+export const REPOS = {
+
+  // ── Backend (pick one) ────────────────────────────────────────────
+  backend: [
+    {
+      id:    'api-nest',
+      label: 'NestJS',
+      hint:  'TypeScript, REST/GraphQL, modular architecture',
+      url:   'https://github.com/tyndareosmasselos/Boilerplater.NestJS',
+    },
+    {
+      id:    'api-dotnet',
+      label: '.NET Microservices',
+      hint:  'C#, microservices, Docker-ready',
+      url:   'https://github.com/tyndareosmasselos/Microservices.Boilerplater',
+    },
+  ],
+
+  // ── Dashboard (fixed — always cloned) ────────────────────────────
+  dashboard: [
+    {
+      id:    'dashboard',
+      label: 'Dashboard',
+      hint:  'Angular admin panel',
+      url:   'https://github.com/tyndareosmasselos/Boilerplater.Web',
+      fixed: true,
+    },
+  ],
+
+  // ── Frontend (pick one) ───────────────────────────────────────────
+  // Add Next.js and Astro repos here when ready:
+  //
+  // frontend: [
+  //   {
+  //     id:    'web-next',
+  //     label: 'Next.js',
+  //     hint:  'React, App Router, SSR',
+  //     url:   'https://github.com/tyndareosmasselos/Boilerplater.Next',
+  //   },
+  //   {
+  //     id:    'web-astro',
+  //     label: 'Astro',
+  //     hint:  'Content-first, islands architecture',
+  //     url:   'https://github.com/tyndareosmasselos/Boilerplater.Astro',
+  //   },
+  // ],
+
+};

package/src/scaffold.js

@@ -0,0 +1,69 @@
+import { join, resolve } from 'path';
+import fs from 'fs';
+
+export async function writeRootFiles({ projectName, selected, backendId, frontendId }) {
+  const projectDir = resolve(process.cwd(), projectName);
+
+  // ── .gitignore ────────────────────────────────────────────────────
+  const gitignore = [
+    '.DS_Store',
+    '*.log',
+    'node_modules/',
+    '.env',
+    '.env.local',
+    '',
+    '# IDE',
+    '.idea/',
+    '.vscode/',
+    '*.suo',
+    '*.user',
+  ].join('\n');
+
+  fs.writeFileSync(join(projectDir, '.gitignore'), gitignore, 'utf8');
+
+  // ── README.md ─────────────────────────────────────────────────────
+  const repoLines = selected
+    .map(r => `| \`code/${r.id}\` | ${r.label} | ${r.url} |`)
+    .join('\n');
+
+  const hasFrontend = !!frontendId;
+
+  const readme = `# ${projectName}
+
+> Scaffolded with \`create-myapp\`
+
+## Structure
+
+\`\`\`
+${projectName}/
+└── code/
+${selected.map(r => `    ├── ${r.id}/`).join('\n')}
+\`\`\`
+
+## Repos
+
+| Folder | Name | Source |
+|--------|------|--------|
+${repoLines}
+
+## Getting started
+
+Each piece is self-contained. Navigate into a folder and follow its own README:
+
+\`\`\`bash
+# Backend
+cd code/${backendId}
+# follow README inside
+
+# Dashboard
+cd code/dashboard
+# follow README inside
+${hasFrontend ? `
+# Frontend
+cd code/${frontendId}
+# follow README inside` : ''}
+\`\`\`
+`;
+
+  fs.writeFileSync(join(projectDir, 'README.md'), readme, 'utf8');
+}

package/src/template.js

@@ -0,0 +1,33 @@
+/**
+ * Renders a template string by replacing {{variable}} tokens.
+ *
+ * Available variables in templates:
+ *   {{projectName}}   — the project name
+ *   {{framework}}     — next | astro
+ *   {{css}}           — tailwind | scss | vanilla
+ *   {{pm}}            — pnpm | npm | bun
+ *   {{year}}          — current year
+ *   {{hasFeature:X}}  — "true" | "false" for any feature X
+ */
+export function renderTemplate(content, ctx) {
+  const { projectName, framework, include = [], css, pm } = ctx;
+
+  const vars = {
+    projectName,
+    framework,
+    css,
+    pm,
+    year: new Date().getFullYear().toString(),
+  };
+
+  // Inject hasFeature:X booleans
+  const allFeatures = ['dashboard', 'webapi', 'blog', 'seo', 'auth', 'cms', 'i18n', 'analytics'];
+  for (const f of allFeatures) {
+    vars[`hasFeature:${f}`] = include.includes(f) ? 'true' : 'false';
+  }
+
+  // Replace {{key}} tokens
+  return content.replace(/\{\{(\w+(?::\w+)?)\}\}/g, (_, key) => {
+    return vars[key] ?? `{{${key}}}`;
+  });
+}

package/src/utils.js

@@ -0,0 +1,6 @@
+export function validateProjectName(value) {
+  if (!value || value.trim().length === 0) return 'Project name is required.';
+  if (!/^[a-z0-9._-]+$/i.test(value)) return 'Only letters, numbers, hyphens, dots and underscores allowed.';
+  if (value.startsWith('-') || value.startsWith('.')) return 'Name cannot start with a hyphen or dot.';
+  return undefined;
+}