create-scaffold-ai 1.0.0

package/bin/create-scaffold-ai.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { run } from '../src/index.js';
+
+try {
+  await run(process.argv.slice(2));
+} catch (err) {
+  console.error(`\nerror: ${err.message}`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "create-scaffold-ai",
+  "version": "1.0.0",
+  "description": "Tiny zero-deps project scaffolder: local + git templates, {{vars}}, pm install",
+  "keywords": [
+    "scaffold",
+    "scaffolding",
+    "generator",
+    "template",
+    "create",
+    "starter-kit"
+  ],
+  "license": "MIT",
+  "author": "sameer_dhara",
+  "type": "module",
+  "main": "scaffold.config.js",
+  "bin": {
+    "create-scaffold-ai": "bin/create-scaffold-ai.js"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "scaffold.config.js"
+  ],
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scaffold.config.js

@@ -0,0 +1,9 @@
+export default {
+  templates: [
+    // Local example:
+    // { name: 'my-api', source: './templates/my-api' },
+    // Git examples (all supported):
+    // { name: 'starter', source: 'gh:user/repo' },
+    // { name: 'starter', source: 'https://github.com/user/repo.git' },
+  ],
+};

package/src/copy.js

@@ -0,0 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function replaceVars(str, vars) {
+  let out = str;
+  for (const [k, v] of Object.entries(vars)) {
+    out = out.split(`{{${k}}}`).join(String(v ?? ''));
+    out = out.split(`__${k}__`).join(String(v ?? ''));
+  }
+  return out;
+}
+
+const SKIP_DIRS = new Set(['node_modules', '.git', '.DS_Store']);
+const BINARY_EXT = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip',
+  '.woff', '.woff2', '.ttf', '.eot', '.mp4', '.mov',
+]);
+
+export function listFiles(dir, base = dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...listFiles(full, base));
+    else out.push(path.relative(base, full));
+  }
+  return out;
+}
+
+export function copyTemplate(srcDir, destDir, vars, { dryRun = false } = {}) {
+  const files = listFiles(srcDir);
+  const written = [];
+  for (const rel of files) {
+    if (rel === 'scaffold.json') continue; // per-template meta, don't copy
+    const targetRel = replaceVars(rel, vars);
+    const srcFile = path.join(srcDir, rel);
+    const destFile = path.join(destDir, targetRel);
+    written.push(targetRel);
+
+    if (dryRun) continue;
+    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+
+    const ext = path.extname(srcFile).toLowerCase();
+    const buf = fs.readFileSync(srcFile);
+    if (BINARY_EXT.has(ext) || buf.includes(0)) {
+      fs.copyFileSync(srcFile, destFile);
+    } else {
+      fs.writeFileSync(destFile, replaceVars(buf.toString('utf8'), vars));
+    }
+  }
+  return written;
+}
+
+export function readTemplateMeta(templateDir) {
+  const metaPath = path.join(templateDir, 'scaffold.json');
+  if (!fs.existsSync(metaPath)) return { variables: [] };
+  try {
+    return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+  } catch {
+    return { variables: [] };
+  }
+}

package/src/git.js

@@ -0,0 +1,26 @@
+import { spawnSync } from 'node:child_process';
+
+export function isGitSource(s) {
+  if (!s) return false;
+  return (
+    s.startsWith('http://') ||
+    s.startsWith('https://') ||
+    s.startsWith('git@') ||
+    s.startsWith('gh:') ||
+    s.startsWith('github:') ||
+    s.endsWith('.git') ||
+    /^[\w-]+\/[\w.-]+$/.test(s)
+  );
+}
+
+export function resolveGitUrl(s) {
+  if (s.startsWith('gh:')) return `https://github.com/${s.slice(3)}.git`;
+  if (s.startsWith('github:')) return `https://github.com/${s.slice(7)}.git`;
+  if (/^[\w-]+\/[\w.-]+$/.test(s)) return `https://github.com/${s}.git`;
+  return s;
+}
+
+export function cloneShallow(gitUrl, destDir) {
+  const r = spawnSync('git', ['clone', '--depth', '1', gitUrl, destDir], { stdio: 'inherit' });
+  if (r.status !== 0) throw new Error(`git clone failed for ${gitUrl}`);
+}

package/src/index.js

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { ask, choose, confirm } from './prompt.js';
+import { copyTemplate, readTemplateMeta } from './copy.js';
+import { isGitSource, resolveGitUrl, cloneShallow } from './git.js';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(here, '..');
+
+export function parseArgs(argv) {
+  const opts = {
+    name: null,
+    template: null,
+    pm: null,
+    install: true,
+    git: true,
+    yes: false,
+    dryRun: false,
+  };
+  const pos = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--template' || a === '-t') opts.template = argv[++i];
+    else if (a === '--pm') opts.pm = argv[++i];
+    else if (a === '--no-install') opts.install = false;
+    else if (a === '--no-git') opts.git = false;
+    else if (a === '--yes' || a === '-y') opts.yes = true;
+    else if (a === '--dry-run') opts.dryRun = true;
+    else if (a === '--help' || a === '-h') opts.help = true;
+    else if (!a.startsWith('-')) pos.push(a);
+  }
+  if (pos[0] && !opts.name) opts.name = pos[0];
+  return opts;
+}
+
+export async function loadUserConfig(cwd) {
+  const names = ['scaffold.config.js', 'scaffold.config.mjs'];
+  for (const n of names) {
+    const p = path.join(cwd, n);
+    if (fs.existsSync(p)) {
+      const mod = await import(`file://${p}?t=${Date.now()}`);
+      return mod.default ?? mod;
+    }
+  }
+  return null;
+}
+
+function builtinTemplates() {
+  return [{ name: 'basic', source: path.join(PKG_ROOT, 'templates/basic') }];
+}
+
+export function resolveTemplate(nameOrSource, userConfig) {
+  const all = [...builtinTemplates(), ...((userConfig && userConfig.templates) || [])];
+  const found = all.find((t) => t.name === nameOrSource);
+  if (found) return found;
+  // direct path or git url also allowed
+  if (nameOrSource) return { name: nameOrSource, source: nameOrSource };
+  return null;
+}
+
+function runInstall(pm, cwd) {
+  const cmds = {
+    npm: ['npm', ['install'], {}],
+    pnpm: ['pnpm', ['install'], {}],
+    yarn: ['yarn', [], {}],
+    bun: ['bun', ['install'], {}],
+  };
+  const [cmd, args] = cmds[pm] || cmds.npm;
+  const r = spawnSync(cmd, args, { cwd, stdio: 'inherit', shell: process.platform === 'win32' });
+  if (r.status !== 0) throw new Error(`${pm} install failed`);
+}
+
+export async function run(argv, cwd = process.cwd()) {
+  const opts = parseArgs(argv);
+  if (opts.help || !opts.name) {
+    if (!opts.help && opts.yes && !opts.name) throw new Error('project name required with --yes');
+    if (!opts.help) {
+      // interactive mode
+      opts.name = opts.name ?? (await ask('Project name', 'my-app'));
+      const userConfig = await loadUserConfig(cwd);
+      const all = [...builtinTemplates(), ...((userConfig && userConfig.templates) || [])];
+      const names = all.map((t) => t.name);
+      opts.template = opts.template ?? (names.length ? await choose('Template', names, 0) : './templates/basic');
+      opts.pm = opts.pm ?? (await choose('Package manager', ['npm', 'pnpm', 'yarn', 'bun'], 0));
+      if (opts.install) opts.install = await confirm('Install dependencies?', true);
+      if (opts.git) opts.git = await confirm('Init git repo?', true);
+      return await scaffold({ ...opts, userConfig });
+    }
+  }
+  if (opts.help) {
+    console.log(`Usage: create-scaffold-ai <name> [options]
+Options:
+  -t, --template <name|path|git-url>  template to use
+  --pm <npm|pnpm|yarn|bun>             package manager
+  --no-install                        skip dependency install
+  --no-git                            skip git init
+  -y, --yes                           skip prompts, use defaults
+  --dry-run                           list files without writing
+  -h, --help                          show this help`);
+    return;
+  }
+  const userConfig = await loadUserConfig(cwd);
+  if (!opts.template) {
+    const all = [...builtinTemplates(), ...((userConfig && userConfig.templates) || [])];
+    opts.template = opts.yes ? all[0].name : await choose('Template', all.map((t) => t.name), 0);
+  }
+  if (!opts.pm) opts.pm = opts.yes ? 'npm' : await choose('Package manager', ['npm', 'pnpm', 'yarn', 'bun'], 0);
+  return await scaffold({ ...opts, userConfig });
+}
+
+export async function scaffold({ name, template, pm = 'npm', install = true, git = true, yes = false, dryRun = false, userConfig = null, cwd = process.cwd() }) {
+  const targetDir = path.resolve(cwd, name);
+  if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0 && !dryRun) {
+    throw new Error(`directory ${name} already exists and is not empty`);
+  }
+
+  const tpl = resolveTemplate(template, userConfig);
+  if (!tpl) throw new Error(`template not found: ${template}`);
+  let source = tpl.source;
+
+  // temp dir for git sources
+  let tmpDir = null;
+  let templateDir = source;
+  if (isGitSource(source) && !fs.existsSync(path.resolve(cwd, source))) {
+    const url = resolveGitUrl(source);
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'scaffold-'));
+    console.log(`Cloning ${url} ...`);
+    if (!dryRun) cloneShallow(url, tmpDir);
+    templateDir = tmpDir;
+  } else {
+    templateDir = path.isAbsolute(source) ? source : path.resolve(cwd, source);
+    // fall back to built-in if relative to package root
+    if (!fs.existsSync(templateDir)) {
+      const inPkg = path.join(PKG_ROOT, source);
+      if (fs.existsSync(inPkg)) templateDir = inPkg;
+    }
+  }
+  if (!dryRun && !fs.existsSync(templateDir)) throw new Error(`template directory not found: ${templateDir}`);
+
+  const meta = dryRun ? { variables: [] } : readTemplateMeta(templateDir);
+  const vars = { name: path.basename(targetDir), pm };
+  if (!yes) {
+    vars.description = await ask('Description', `${vars.name} — built with create-scaffold-ai`);
+    vars.author = await ask('Author', '');
+    for (const key of meta.variables || []) {
+      if (!(key in vars)) vars[key] = await ask(key, '');
+    }
+  } else {
+    vars.description = `${vars.name} — built with create-scaffold-ai`;
+    vars.author = '';
+  }
+
+  console.log(`\nScaffolding ${vars.name} from ${tpl.name} -> ${targetDir}`);
+  const written = dryRun
+    ? []
+    : copyTemplate(templateDir, targetDir, vars, { dryRun });
+
+  if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  if (dryRun) {
+    console.log('(dry run) nothing written.');
+    return { targetDir, vars, written: [] };
+  }
+
+  console.log(`Wrote ${written.length} files.`);
+  if (git) {
+    const r = spawnSync('git', ['init'], { cwd: targetDir, stdio: 'ignore' });
+    if (r.status === 0) console.log('Initialized git repo.');
+  }
+  if (install) {
+    console.log(`Installing with ${pm} ...`);
+    runInstall(pm, targetDir);
+  }
+  console.log(`\nDone. Next:\n  cd ${name}\n  ${pm === 'npm' ? 'npm run dev' : `${pm} dev`}`);
+  return { targetDir, vars, written };
+}

package/src/prompt.js

@@ -0,0 +1,30 @@
+import readline from 'node:readline';
+
+function rl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+export async function ask(question, def = '') {
+  const r = rl();
+  const suffix = def ? ` (${def})` : '';
+  const ans = await new Promise((resolve) => r.question(`${question}${suffix}: `, resolve));
+  r.close();
+  const trimmed = ans.trim();
+  return trimmed || def;
+}
+
+export async function choose(question, options, defIndex = 0) {
+  console.log(`\n${question}`);
+  options.forEach((o, i) => console.log(`  ${i + 1}) ${o}`));
+  const ans = await ask(`Enter 1-${options.length}`, String(defIndex + 1));
+  const n = parseInt(ans, 10);
+  if (Number.isInteger(n) && n >= 1 && n <= options.length) return options[n - 1];
+  return options[defIndex];
+}
+
+export async function confirm(question, def = true) {
+  const hint = def ? 'Y/n' : 'y/N';
+  const ans = await ask(`${question} [${hint}]`, '');
+  if (!ans) return def;
+  return /^y(es)?$/i.test(ans.trim());
+}

package/templates/basic/index.js

@@ -0,0 +1,2 @@
+console.log('Hello from {{name}}!');
+console.log('Built with {{pm}} · {{description}}');

package/templates/basic/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "type": "module",
+  "scripts": {
+    "dev": "node index.js"
+  }
+}

package/templates/basic/scaffold.json

@@ -0,0 +1,3 @@
+{
+  "variables": []
+}