mez-easyjs 0.1.0

package/src/commands/create.js

@@ -0,0 +1,476 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, '../..');
+const MONOREPO_ROOT = path.resolve(PKG_ROOT, '../..');
+const TEMPLATES_ROOT = path.resolve(PKG_ROOT, 'templates');
+
+const TEMPLATES = {
+  minimal: {
+    id: 'minimal',
+    label: 'Minimal / Empty',
+    description: 'Clean skeleton — easy.config.js, App.easy, least deps'
+  },
+  starter: {
+    id: 'starter',
+    label: 'Starter / Example',
+    description: 'Counter, routing, parent→child props — ready for npm run dev'
+  },
+  tailwind: {
+    id: 'tailwind',
+    label: 'Tailwind (CDN)',
+    description: 'Play CDN utilities in markup — no PostCSS / npm tailwindcss'
+  }
+};
+
+const NPM_NAME_RE =
+  /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+
+const c = {
+  reset: '\x1b[0m',
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  magenta: (s) => `\x1b[35m${s}\x1b[0m`
+};
+
+/**
+ * Scaffold a new Easy.js project (interactive wizard by default).
+ *
+ * Flags:
+ *   --name <n>           Project name (also positional arg)
+ *   --template <id>      minimal | starter | tailwind
+ *   --lang <js|ts>       Language (only js supported in MVP)
+ *   --cwd <dir>          Parent directory for the project
+ *   --yes / -y           Accept defaults; skip prompts when possible
+ *   --skip-install       Do not run npm install
+ *   --skip-git           Do not git init / commit
+ */
+export async function createProject(nameArg, flags = {}) {
+  const parentDir = path.resolve(flags.cwd || process.cwd());
+  const interactive = process.stdin.isTTY && !flags.yes && !flags.y;
+
+  console.log(`
+${c.cyan(c.bold('  easy.js'))} ${c.dim('— create a new project')}
+`);
+
+  let projectName =
+    flags.name ||
+    nameArg ||
+    (interactive ? await promptName() : null) ||
+    'easy-app';
+
+  projectName = String(projectName).trim();
+  const nameCheck = validateNpmName(projectName);
+  if (!nameCheck.ok) {
+    throw new Error(nameCheck.error);
+  }
+
+  let language =
+    normalizeLang(flags.lang || flags.language) ||
+    (interactive ? await promptLanguage() : 'js');
+  if (language === 'ts') {
+    console.log(
+      c.yellow(
+        '  TypeScript scaffolding is not available yet — using JavaScript.\n'
+      )
+    );
+    language = 'js';
+  }
+
+  let templateId =
+    normalizeTemplate(flags.template || flags.t) ||
+    (interactive ? await promptTemplate() : 'starter');
+
+  if (!TEMPLATES[templateId]) {
+    throw new Error(
+      `Unknown template "${templateId}". Use: minimal | starter | tailwind`
+    );
+  }
+
+  const target = path.resolve(parentDir, projectName);
+  // Path traversal protection — project must stay under the chosen parent.
+  const relToParent = path.relative(parentDir, target);
+  if (
+    !relToParent ||
+    relToParent.startsWith('..') ||
+    path.isAbsolute(relToParent)
+  ) {
+    throw new Error('Invalid project path (path traversal blocked).');
+  }
+  if (fs.existsSync(target) && fs.readdirSync(target).length > 0) {
+    throw new Error(`Directory not empty: ${target}`);
+  }
+
+  if (interactive) {
+    const ok = await confirm(
+      `Create ${c.bold(projectName)} (${TEMPLATES[templateId].label}, ${language}) in\n  ${target}?`
+    );
+    if (!ok) {
+      console.log(c.dim('  Cancelled.'));
+      return;
+    }
+  }
+
+  const templateDir = path.join(TEMPLATES_ROOT, templateId);
+  if (!fs.existsSync(templateDir)) {
+    throw new Error(`Template files missing: ${templateDir}`);
+  }
+
+  fs.mkdirSync(target, { recursive: true });
+  const vars = {
+    project_name: projectName,
+    projectName,
+    PROJECT_NAME: projectName
+  };
+  copyDir(templateDir, target, vars);
+
+  writePackageJson(target, projectName, templateId);
+  writeGitignore(target);
+
+  if (!flags['skip-git'] && !flags.skipGit) {
+    initGit(target);
+  }
+
+  if (!flags['skip-install'] && !flags.skipInstall) {
+    console.log(c.dim('\n  Installing dependencies…\n'));
+    const install = runNpmInstall(target);
+    if (!install.ok) {
+      console.log(
+        c.yellow(
+          `  npm install failed (you can run it manually in ${projectName}).\n  ${install.error || ''}`
+        )
+      );
+    }
+  }
+
+  if (!flags['skip-git'] && !flags.skipGit) {
+    initialCommit(target, projectName, templateId);
+  }
+
+  printSuccess({ projectName, templateId, language, target });
+}
+
+export function validateNpmName(name) {
+  if (!name || !String(name).trim()) {
+    return { ok: false, error: 'Project name cannot be empty.' };
+  }
+  const n = String(name).trim();
+  if (n === '.' || n === '..' || n.includes('..')) {
+    return { ok: false, error: 'Invalid project name.' };
+  }
+  if (/[\\]/.test(n) || /[\0]/.test(n)) {
+    return { ok: false, error: 'Project name cannot contain path separators.' };
+  }
+  // Allow a single / only for scoped packages (@scope/name).
+  const slashCount = (n.match(/\//g) || []).length;
+  if (slashCount > (n.startsWith('@') ? 1 : 0)) {
+    return { ok: false, error: 'Invalid project name (too many path segments).' };
+  }
+  if (/\s/.test(n)) {
+    return { ok: false, error: 'Project name cannot contain spaces.' };
+  }
+  if (/[A-Z]/.test(n)) {
+    return {
+      ok: false,
+      error: 'Project name must be lowercase (npm package rules).'
+    };
+  }
+  if (!NPM_NAME_RE.test(n)) {
+    return {
+      ok: false,
+      error:
+        'Invalid npm package name. Use lowercase letters, digits, hyphens, or @scope/name.'
+    };
+  }
+  if (n.startsWith('.') || n.startsWith('_')) {
+    return { ok: false, error: 'Project name cannot start with . or _.' };
+  }
+  return { ok: true };
+}
+
+function normalizeTemplate(raw) {
+  if (!raw || raw === true) return null;
+  const id = String(raw).toLowerCase().trim();
+  if (id === 'empty') return 'minimal';
+  if (id === 'example' || id === 'demo') return 'starter';
+  if (id === 'tw') return 'tailwind';
+  return TEMPLATES[id] ? id : id;
+}
+
+function normalizeLang(raw) {
+  if (!raw || raw === true) return null;
+  const v = String(raw).toLowerCase().trim();
+  if (v === 'javascript' || v === 'js') return 'js';
+  if (v === 'typescript' || v === 'ts') return 'ts';
+  return v;
+}
+
+async function promptName() {
+  const answer = await ask(`  ${c.bold('Project name:')} `, 'easy-app');
+  const check = validateNpmName(answer);
+  if (!check.ok) {
+    console.log(c.red(`  ✖ ${check.error}`));
+    return promptName();
+  }
+  return answer.trim();
+}
+
+async function promptLanguage() {
+  console.log(`
+  ${c.bold('Language')}
+    ${c.cyan('1)')} JavaScript ${c.green('(available)')}
+    ${c.dim('2) TypeScript  — coming soon (not available yet)')}
+`);
+  const answer = await ask('  Choose [1]: ', '1');
+  if (answer.trim() === '2' || /^ts/i.test(answer)) {
+    return 'ts';
+  }
+  return 'js';
+}
+
+async function promptTemplate() {
+  const ids = Object.keys(TEMPLATES);
+  console.log(`\n  ${c.bold('Template')}`);
+  ids.forEach((id, i) => {
+    const t = TEMPLATES[id];
+    console.log(
+      `    ${c.cyan(`${i + 1})`)} ${t.label}  ${c.dim(`— ${t.description}`)}`
+    );
+  });
+  console.log();
+  const answer = await ask('  Choose [2]: ', '2');
+  const n = Number(answer.trim());
+  if (n >= 1 && n <= ids.length) return ids[n - 1];
+  const byId = normalizeTemplate(answer);
+  if (TEMPLATES[byId]) return byId;
+  console.log(c.yellow('  Using starter.'));
+  return 'starter';
+}
+
+async function confirm(message) {
+  console.log(`\n  ${message}`);
+  const answer = await ask(`  ${c.bold('Continue?')} [Y/n] `, 'y');
+  return !/^(n|no)$/i.test(answer.trim());
+}
+
+function ask(question, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      const v = answer.trim();
+      resolve(v || defaultValue);
+    });
+  });
+}
+
+function copyDir(src, dest, vars) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const name of fs.readdirSync(src)) {
+    if (name === '.git' || name === 'node_modules') continue;
+    const from = path.join(src, name);
+    const to = path.join(dest, name);
+    const st = fs.statSync(from);
+    if (st.isDirectory()) {
+      copyDir(from, to, vars);
+    } else {
+      let content = fs.readFileSync(from);
+      const textLike = /\.(html?|js|mjs|cjs|json|css|md|easy|ejs|txt|svg)$/i.test(
+        name
+      );
+      if (textLike) {
+        let text = content.toString('utf8');
+        text = applyVars(text, vars);
+        fs.writeFileSync(to, text);
+      } else {
+        fs.writeFileSync(to, content);
+      }
+    }
+  }
+}
+
+function applyVars(text, vars) {
+  let out = text;
+  for (const [key, value] of Object.entries(vars)) {
+    out = out.split(`{{${key}}}`).join(value);
+  }
+  return out;
+}
+
+function writePackageJson(target, projectName, templateId) {
+  const pkgPath = path.join(target, 'package.json');
+  let pkg;
+  if (fs.existsSync(pkgPath)) {
+    pkg = JSON.parse(applyVars(fs.readFileSync(pkgPath, 'utf8'), { projectName, project_name: projectName }));
+  } else {
+    pkg = {
+      name: projectName,
+      version: '0.1.0',
+      private: true,
+      type: 'module',
+      scripts: {
+        dev: 'easy dev',
+        build: 'easy build'
+      }
+    };
+  }
+
+  pkg.name = projectName;
+  // Prefer file: links into this monorepo when available; else version pins.
+  pkg.dependencies = resolveEasyDependencies(target);
+
+  if (!pkg.scripts) pkg.scripts = {};
+  if (!pkg.scripts.dev) pkg.scripts.dev = 'easy dev';
+  if (!pkg.scripts.build) pkg.scripts.build = 'easy build';
+
+  pkg.easyTemplate = templateId;
+
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+
+/**
+ * Prefer file: links into this monorepo when present (local development).
+ * Fall back to published version numbers for consumers of published packages.
+ */
+/** Semver range used when scaffolding outside this monorepo (published path). */
+const PUBLISHED_RANGE = '^0.1.0';
+
+/**
+ * Prefer file: links into this monorepo when present (local development).
+ * Fall back to published semver ranges for consumers of published packages.
+ */
+function resolveEasyDependencies(targetDir) {
+  const local = path.join(MONOREPO_ROOT, 'packages', 'easyjs');
+  const pkgJson = path.join(local, 'package.json');
+  if (fs.existsSync(pkgJson)) {
+    let rel = path.relative(targetDir, local);
+    rel = rel.split(path.sep).join('/');
+    if (!rel.startsWith('.')) rel = `./${rel}`;
+    return { 'mez-easyjs': `file:${rel}` };
+  }
+  return { 'mez-easyjs': PUBLISHED_RANGE };
+}
+
+function writeGitignore(target) {
+  const dest = path.join(target, '.gitignore');
+  if (fs.existsSync(dest)) return;
+  fs.writeFileSync(
+    dest,
+    `# easy.js
+node_modules/
+dist/
+.easy/
+.cache/
+coverage/
+*.log
+.DS_Store
+Thumbs.db
+*.local
+.env
+.env.*
+`
+  );
+}
+
+function hasGit() {
+  const r = spawnSync('git', ['--version'], { encoding: 'utf8' });
+  return r.status === 0;
+}
+
+function initGit(target) {
+  if (!hasGit()) {
+    console.log(c.dim('  git not available — skipping git init'));
+    return;
+  }
+  const r = spawnSync('git', ['init'], { cwd: target, encoding: 'utf8' });
+  if (r.status !== 0) {
+    console.log(c.dim('  git init failed — skipping'));
+  }
+}
+
+function initialCommit(target, projectName, templateId) {
+  if (!hasGit()) return;
+  if (!fs.existsSync(path.join(target, '.git'))) return;
+
+  spawnSync('git', ['add', '-A'], { cwd: target, encoding: 'utf8' });
+  const msg = `chore: initial commit from easy create (${templateId})\n\nScaffolded ${projectName} with the ${templateId} template.`;
+  const r = spawnSync('git', ['commit', '-m', msg], {
+    cwd: target,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || 'easy create',
+      GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || 'easy@localhost',
+      GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || 'easy create',
+      GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || 'easy@localhost'
+    }
+  });
+  if (r.status !== 0) {
+    console.log(
+      c.dim(
+        '  git commit skipped (configure user.name / user.email, or commit manually)'
+      )
+    );
+  }
+}
+
+function runNpmInstall(target) {
+  const isWin = process.platform === 'win32';
+  const npmCmd = isWin ? 'npm.cmd' : 'npm';
+  const r = spawnSync(npmCmd, ['install'], {
+    cwd: target,
+    encoding: 'utf8',
+    stdio: 'inherit',
+    // Avoid shell:true (DEP0190); npm.cmd is invokable directly on Windows.
+    windowsHide: true
+  });
+  return {
+    ok: r.status === 0,
+    error: r.status === 0 ? null : `exit ${r.status}`
+  };
+}
+
+function printSuccess({ projectName, templateId, language, target }) {
+  const art = `
+${c.cyan('   ___  __ _ ___ _   _')}
+${c.cyan('  / _ \\/ _` / __| | | |')}
+${c.cyan(' |  __/ (_| \\__ \\ |_| |')}
+${c.cyan('  \\___|\\__,_|___/\\__, |')}
+${c.cyan('                 |___/ ')}${c.bold('.js')}
+`;
+
+  console.log(art);
+  console.log(c.green(c.bold('  ✔ Project ready!\n')));
+  console.log(`  ${c.bold('Name:')}      ${projectName}`);
+  console.log(`  ${c.bold('Template:')}  ${TEMPLATES[templateId].label} (${templateId})`);
+  console.log(`  ${c.bold('Language:')}  ${language === 'js' ? 'JavaScript' : language}`);
+  console.log(`  ${c.bold('Path:')}      ${target}`);
+  if (templateId === 'tailwind') {
+    console.log(
+      `\n  ${c.dim('Tailwind via Play CDN (@tailwindcss/browser) — no PostCSS.')}`
+    );
+  }
+  console.log(`
+  ${c.bold('Next steps:')}
+
+    ${c.cyan(`cd ${projectName}`)}
+    ${c.cyan('npm run dev')}
+
+  ${c.dim('Docs:     https://github.com/easyjs/easy-js')}
+  ${c.dim('Issues:   https://github.com/easyjs/easy-js/issues')}
+`);
+}
+
+// Re-export registry for tests / help
+export { TEMPLATES, TEMPLATES_ROOT, PKG_ROOT };