create-epinoetics-app 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-epinoetics-app",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Scaffold a new project from your boilerplate repos",
   "type": "module",
   "bin": {

package/src/cloner.js

@@ -4,50 +4,75 @@ import { resolve, join } from 'path';
 import { simpleGit } from 'simple-git';
 import fs from 'fs';
 
-// ── Clone all plain repos (dashboard, dotnet, frontend) ───────────
-export async function cloneAll({ projectName, repos }) {
+// ── Initialize the root project repo ─────────────────────────────
+export async function initRootRepo({ projectName }) {
   const projectDir = resolve(process.cwd(), projectName);
-  const codeDir    = join(projectDir, 'code');
+  fs.mkdirSync(projectDir, { recursive: true });
 
-  fs.mkdirSync(codeDir, { recursive: true });
+  const git = simpleGit(projectDir);
+  await git.init();
+
+  // Initial empty commit so subtree add works
+  await git.commit('chore: init project', { '--allow-empty': null });
+
+  p.log.step(`Initialized git repo  ${chalk.dim(`→ ${projectName}`)}`);
+
+  return projectDir;
+}
+
+// ── Add a plain repo as a subtree (dashboard, dotnet, frontend) ───
+export async function addSubtrees({ projectDir, repos }) {
+  const git = simpleGit(projectDir);
 
   for (const repo of repos) {
-    const dest    = join(codeDir, repo.id);
+    const prefix  = `code/${repo.id}`;
     const spinner = p.spinner();
 
-    spinner.start(`Cloning ${chalk.cyan(repo.label)}  ${chalk.dim(repo.url)}`);
+    spinner.start(`Adding ${chalk.cyan(repo.label)}  ${chalk.dim(`→ ${prefix}`)}`);
 
     try {
-      await simpleGit().clone(repo.url, dest, ['--depth=1']);
-      fs.rmSync(join(dest, '.git'), { recursive: true, force: true });
-      spinner.stop(`${chalk.green('✓')} ${repo.label}  ${chalk.dim(`→ code/${repo.id}`)}`);
+      await git.raw([
+        'subtree', 'add',
+        '--prefix', prefix,
+        repo.url,
+        'master',
+        '--squash',
+      ]);
+
+      spinner.stop(`${chalk.green('✓')} ${repo.label}  ${chalk.dim(`→ ${prefix}`)}`);
     } catch (err) {
       spinner.stop(`${chalk.red('✗')} ${repo.label}  ${chalk.dim(err.message)}`);
-      throw new Error(`Failed to clone ${repo.label}: ${err.message}`);
+      throw new Error(`Failed to add subtree ${repo.label}: ${err.message}`);
     }
   }
 }
 
-// ── Clone NestJS db branch, then prune unselected features ────────
-export async function cloneAndMergeNest({ projectName, database, selectedFeatures, allFeatures, repoUrl }) {
-  const projectDir = resolve(process.cwd(), projectName);
-  const dest       = join(projectDir, 'code', 'api-nest');
-
-  fs.mkdirSync(dest, { recursive: true });
+// ── Add NestJS as subtree, then prune unselected features ─────────
+export async function addNestSubtree({ projectDir, database, selectedFeatures, allFeatures, repoUrl }) {
+  const git    = simpleGit(projectDir);
+  const prefix = 'code/webapi';
+  const dest   = join(projectDir, prefix);
 
-  // 1. Clone the chosen db branch directly
+  // 1. Add NestJS as subtree
   const spinner = p.spinner();
-  spinner.start(`Cloning ${chalk.cyan('NestJS')}  ${chalk.dim(`branch: ${database.branch}`)}`);
+  spinner.start(`Adding ${chalk.cyan('NestJS')}  ${chalk.dim(`branch: ${database.branch}`)}`);
 
   try {
-    await simpleGit().clone(repoUrl, dest, ['--branch', database.branch, '--single-branch']);
-    spinner.stop(`${chalk.green('✓')} NestJS  ${chalk.dim(`→ code/api-nest  (${database.branch})`)}`);
+    await git.raw([
+      'subtree', 'add',
+      '--prefix', prefix,
+      repoUrl,
+      database.branch,
+      '--squash',
+    ]);
+
+    spinner.stop(`${chalk.green('✓')} NestJS  ${chalk.dim(`→ ${prefix}  (${database.branch})`)}`);
   } catch (err) {
     spinner.stop(`${chalk.red('✗')} NestJS  ${chalk.dim(err.message)}`);
-    throw new Error(`Failed to clone NestJS repo: ${err.message}`);
+    throw new Error(`Failed to add NestJS subtree: ${err.message}`);
   }
 
-  // 2. Remove unselected feature folders from src/features/
+  // 2. Remove unselected feature folders
   const selectedIds = new Set(selectedFeatures.map(f => f.id));
   const toRemove    = allFeatures.filter(f => !selectedIds.has(f.id));
 
@@ -64,7 +89,7 @@ export async function cloneAndMergeNest({ projectName, database, selectedFeature
     );
   }
 
-  // 3. Prune schema — Drizzle or Prisma
+  // 3. Prune schema
   if (database.id === 'drizzle') {
     pruneDrizzleSchema({ dest, toRemove });
   } else if (database.id === 'prisma') {
@@ -74,34 +99,17 @@ export async function cloneAndMergeNest({ projectName, database, selectedFeature
   // 4. Prune app.module.ts
   pruneAppModule({ dest, toRemove });
 
-  // 5. Remove migrations directory
+  // 5. Remove migrations
   pruneMigrations({ dest, database });
 
   // 6. Write scaffold.config.json
   writeScaffoldConfig({ dest, database, selectedFeatures, repoUrl });
 
-  // 7. Strip boilerplate .git and init a fresh one
-  await initFreshGit({ dest });
-}
+  // 7. Commit the pruning changes
+  await git.add('.');
+  await git.commit('chore: prune unselected features');
 
-// ── Strip boilerplate .git, init fresh repo, initial commit ───────
-async function initFreshGit({ dest }) {
-  const spinner = p.spinner();
-  spinner.start('Initializing fresh git repo...');
-
-  try {
-    // Remove the boilerplate's .git
-    fs.rmSync(join(dest, '.git'), { recursive: true, force: true });
-
-    const git = simpleGit(dest);
-    await git.init();
-    await git.add('.');
-    await git.commit('chore: initial scaffold via create-epinoetics-app');
-
-    spinner.stop(`${chalk.green('✓')} Fresh git repo initialized`);
-  } catch (err) {
-    spinner.stop(`${chalk.yellow('⚠')} Git init failed  ${chalk.dim(err.message)}`);
-  }
+  p.log.step(`Committed pruned scaffold`);
 }
 
 // ── Write scaffold.config.json ────────────────────────────────────

package/src/scaffold.js

@@ -1,8 +1,7 @@
-import { join, resolve } from 'path';
+import { join } from 'path';
 import fs from 'fs';
 
-export async function writeRootFiles({ projectName, plainRepos = [], backendId, database, features = [], frontendId }) {
-  const projectDir = resolve(process.cwd(), projectName);
+export async function writeRootFiles({ projectName, projectDir, plainRepos = [], backendId, database, features = [], frontendId }) {
 
   // ── .gitignore ────────────────────────────────────────────────────
   const gitignore = [
@@ -22,37 +21,25 @@ export async function writeRootFiles({ projectName, plainRepos = [], backendId,
   fs.writeFileSync(join(projectDir, '.gitignore'), gitignore, 'utf8');
 
   // ── README.md ─────────────────────────────────────────────────────
-  const nestSection = backendId === 'api-nest' ? `
-## NestJS backend
+  const nestSection = backendId === 'webapi' ? `
+## NestJS Web API
 
 - **Database**: ${database.label}
 - **Features**: ${features.length ? features.map(f => f.label).join(', ') : 'none'}
 
 \`\`\`bash
-cd code/api-nest
+cd code/webapi
 # follow README inside
 \`\`\`
 ` : '';
 
-  const repoLines = plainRepos.map(r =>
-    `| \`code/${r.id}\` | ${r.label} | ${r.url} |`
-  ).join('\n');
-
   const structureLines = [
-    backendId === 'api-nest'   ? '    ├── api-nest/       ← NestJS' : null,
+    backendId === 'webapi'     ? '    ├── webapi/         ← NestJS' : null,
     backendId === 'api-dotnet' ? '    ├── api-dotnet/     ← .NET Microservices' : null,
     '    ├── dashboard/      ← Angular admin panel',
     frontendId ? `    ├── ${frontendId}/` : null,
   ].filter(Boolean).join('\n');
 
-  const repoTableSection = plainRepos.length > 0 ? `
-## Repos
-
-| Folder | Name | Source |
-|--------|------|--------|
-${repoLines}
-` : '';
-
   const readme = `# ${projectName}
 
 > Scaffolded with \`create-epinoetics-app\`
@@ -64,7 +51,13 @@ ${projectName}/
 └── code/
 ${structureLines}
 \`\`\`
-${nestSection}${repoTableSection}
+${nestSection}
+## Pulling boilerplate updates
+
+\`\`\`bash
+npx create-epinoetics-app sync
+\`\`\`
+
 ## Getting started
 
 Each piece is self-contained — navigate into a folder and follow its own README.

package/src/syncer.js

@@ -1,20 +1,9 @@
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { simpleGit } from 'simple-git';
-import { NEST_DATABASES } from './repos.js';
+import { NEST_DATABASES, REPOS } from './repos.js';
 import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-// Paths that are never overwritten during sync
-const PROTECTED = [
-  'src/features',
-  'scaffold.config.json',
-  '.env',
-  '.env.local',
-  '.git',
-];
 
 export async function runSync() {
   console.log('');
@@ -23,116 +12,108 @@ export async function runSync() {
     chalk.dim(' pull latest boilerplate updates')
   );
 
+  // Must be run from project root (where .git is)
   const cwd = process.cwd();
 
-  // ── 1. Read scaffold.config.json ──────────────────────────────────
-  const configPath = join(cwd, 'scaffold.config.json');
-  if (!fs.existsSync(configPath)) {
+  if (!fs.existsSync(join(cwd, '.git'))) {
     p.log.error(
-      'No scaffold.config.json found.\n' +
-      chalk.dim('Make sure you are inside the code/api-nest directory.')
+      'No .git found.\n' +
+      chalk.dim('Run this from your project root, not inside code/webapi.')
     );
     process.exit(1);
   }
 
-  const config   = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  const database = NEST_DATABASES.find(d => d.id === config.database);
+  // ── Check for uncommitted changes ─────────────────────────────────
+  const git    = simpleGit(cwd);
+  const status = await git.status();
 
-  p.note(
-    [
-      `${chalk.dim('branch  '.padEnd(14))} ${chalk.cyan(config.branch)}`,
-      `${chalk.dim('features'.padEnd(14))} ${config.features.length ? config.features.map(f => chalk.cyan(f)).join(chalk.dim(', ')) : chalk.dim('none')}`,
-    ].join('\n'),
-    'Syncing from boilerplate'
-  );
-
-  const confirm = await p.confirm({
-    message: `Pull latest from ${chalk.cyan(config.branch)}? Your code in src/features/ will not be touched.`,
-  });
-  if (p.isCancel(confirm) || !confirm) return cancel();
-
-  // ── 2. Clone latest into temp dir ─────────────────────────────────
-  const tmpDir  = join(os.tmpdir(), `epinoetics-sync-${Date.now()}`);
-  const spinner = p.spinner();
-
-  spinner.start(`Fetching latest from ${chalk.dim(config.branch)}...`);
-
-  try {
-    await simpleGit().clone(config.repoUrl, tmpDir, [
-      '--branch', config.branch,
-      '--single-branch',
-      '--depth=1',
-    ]);
-    spinner.stop(`${chalk.green('✓')} Fetched latest boilerplate`);
-  } catch (err) {
-    spinner.stop(`${chalk.red('✗')} Fetch failed  ${chalk.dim(err.message)}`);
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+  if (!status.isClean()) {
+    p.log.error(
+      'You have uncommitted changes. Commit or stash them first:\n' +
+      chalk.dim(status.files.map(f => `  ${f.working_dir} ${f.path}`).join('\n'))
+    );
     process.exit(1);
   }
 
-  // ── 3. Copy changed files, skipping protected paths ───────────────
-  const copySpinner = p.spinner();
-  copySpinner.start('Applying updates...');
+  // ── Pick what to sync ─────────────────────────────────────────────
+  const choices = buildSyncChoices({ cwd });
 
-  let updated = 0;
-
-  try {
-    updated = syncDirs({ src: tmpDir, dest: cwd });
-    copySpinner.stop(`${chalk.green('✓')} Applied updates  ${chalk.dim(`(${updated} file(s) updated)`)}`);
-  } catch (err) {
-    copySpinner.stop(`${chalk.red('✗')} Sync failed  ${chalk.dim(err.message)}`);
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+  if (choices.length === 0) {
+    p.log.error('No syncable pieces found. Make sure you are in the project root.');
     process.exit(1);
   }
 
-  // ── 4. Cleanup temp dir ───────────────────────────────────────────
-  fs.rmSync(tmpDir, { recursive: true, force: true });
+  const toSync = await p.multiselect({
+    message: 'Which pieces do you want to sync?',
+    options: choices,
+    required: true,
+  });
+  if (p.isCancel(toSync)) return cancel();
+
+  // ── Sync each selected piece ──────────────────────────────────────
+  for (const item of toSync) {
+    const spinner = p.spinner();
+    spinner.start(`Syncing ${chalk.cyan(item.label)}  ${chalk.dim(`${item.prefix} ← ${item.branch}`)}`);
+
+    try {
+      await git.raw([
+        'subtree', 'pull',
+        '--prefix', item.prefix,
+        item.url,
+        item.branch,
+        '--squash',
+        '-m', `chore: sync ${item.prefix} from boilerplate`,
+      ]);
+
+      spinner.stop(`${chalk.green('✓')} ${item.label}  ${chalk.dim('synced')}`);
+    } catch (err) {
+      spinner.stop(`${chalk.red('✗')} ${item.label}  ${chalk.dim(err.message)}`);
+      p.log.warn(`Sync failed for ${item.label} — resolve manually.`);
+    }
+  }
 
-  p.outro(
-    chalk.green('Sync complete!') + '\n\n' +
-    chalk.dim('  Your src/features/ and .env were not touched.\n') +
-    chalk.dim('  Review changes, then commit.')
-  );
+  p.outro(chalk.green('Sync complete!'));
 }
 
-// ── Recursively copy src → dest, skipping protected paths ─────────
-function syncDirs({ src, dest, relative = '' }) {
-  let count = 0;
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const relPath = relative ? `${relative}/${entry.name}` : entry.name;
-
-    // Skip protected paths
-    if (isProtected(relPath)) continue;
-
-    const srcPath  = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-
-    if (entry.isDirectory()) {
-      fs.mkdirSync(destPath, { recursive: true });
-      count += syncDirs({ src: srcPath, dest: destPath, relative: relPath });
-    } else {
-      const srcContent  = fs.readFileSync(srcPath);
-      const destExists  = fs.existsSync(destPath);
-      const destContent = destExists ? fs.readFileSync(destPath) : null;
+// ── Build list of syncable pieces from what exists on disk ────────
+function buildSyncChoices({ cwd }) {
+  const choices = [];
+
+  // NestJS webapi — read config from scaffold.config.json
+  const configPath = join(cwd, 'code', 'webapi', 'scaffold.config.json');
+  if (fs.existsSync(configPath)) {
+    const config   = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const database = NEST_DATABASES.find(d => d.id === config.database);
+    if (database) {
+      choices.push({
+        value:  'webapi',
+        label:  'NestJS Web API',
+        hint:   `branch: ${config.branch}`,
+        prefix: 'code/webapi',
+        url:    config.repoUrl,
+        branch: config.branch,
+      });
+    }
+  }
 
-      // Only write if file changed
-      if (!destContent || !srcContent.equals(destContent)) {
-        fs.writeFileSync(destPath, srcContent);
-        count++;
+  // Dashboard and other fixed repos
+  for (const group of Object.values(REPOS)) {
+    for (const repo of group) {
+      const dir = join(cwd, 'code', repo.id);
+      if (fs.existsSync(dir)) {
+        choices.push({
+          value:  repo.id,
+          label:  repo.label,
+          hint:   repo.url,
+          prefix: `code/${repo.id}`,
+          url:    repo.url,
+          branch: 'master',
+        });
       }
     }
   }
 
-  return count;
-}
-
-// ── Check if a relative path is protected ─────────────────────────
-function isProtected(relPath) {
-  return PROTECTED.some(p =>
-    relPath === p || relPath.startsWith(p + '/') || relPath.startsWith(p + path.sep)
-  );
+  return choices;
 }
 
 function cancel() {