create-epinoetics-app 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-epinoetics-app",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "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,32 +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. Protect src/features/ from future syncs
-  writeGitExclude({ dest });
-
-  // NOTE: .git is intentionally kept so `sync` can pull updates later
-}
+  // 7. Commit the pruning changes
+  await git.add('.');
+  await git.commit('chore: prune unselected features');
 
-// ── Write .git/info/exclude to protect key dirs from sync ─────────
-function writeGitExclude({ dest }) {
-  const excludePath = join(dest, '.git', 'info', 'exclude');
-  const lines = [
-    '# Added by create-epinoetics-app — do not edit',
-    'src/features/',
-    'scaffold.config.json',
-    '.env',
-    '.env.local',
-  ].join('\n');
-
-  fs.mkdirSync(join(dest, '.git', 'info'), { recursive: true });
-  fs.writeFileSync(excludePath, lines, 'utf8');
-  p.log.step(`Protected src/features/ from sync`);
+  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,8 +1,8 @@
 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';
 
 export async function runSync() {
@@ -12,87 +12,110 @@ 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'
-  );
-
-  const confirm = await p.confirm({
-    message: `Pull latest changes from ${chalk.cyan(config.branch)}?`,
-  });
-  if (p.isCancel(confirm) || !confirm) return cancel();
-
-  // ── 2. Make sure .git exists ──────────────────────────────────────
-  const gitDir = join(cwd, '.git');
-  if (!fs.existsSync(gitDir)) {
+  if (!status.isClean()) {
     p.log.error(
-      '.git directory not found.\n' +
-      chalk.dim('Re-scaffold this project to enable sync.')
+      '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. Stash any local changes ────────────────────────────────────
-  const git     = simpleGit(cwd);
-  const spinner = p.spinner();
-
-  spinner.start('Stashing local changes...');
-  try {
-    await git.stash(['push', '--include-untracked', '-m', 'create-epinoetics-app sync']);
-    spinner.stop(`${chalk.green('✓')} Local changes stashed`);
-  } catch {
-    spinner.stop(chalk.dim('Nothing to stash'));
-  }
+  // ── Pick what to sync ─────────────────────────────────────────────
+  const choices = buildSyncChoices({ cwd });
 
-  // ── 4. Pull latest from the db branch ────────────────────────────
-  const pullSpinner = p.spinner();
-  pullSpinner.start(`Pulling latest from ${chalk.cyan(config.branch)}...`);
-
-  try {
-    await git.pull('origin', config.branch, ['--rebase']);
-    pullSpinner.stop(`${chalk.green('✓')} Pulled latest changes`);
-  } catch (err) {
-    pullSpinner.stop(`${chalk.red('✗')} Pull failed  ${chalk.dim(err.message)}`);
-    p.log.warn('Restoring your stashed changes...');
-    await git.stash(['pop']).catch(() => {});
+  if (choices.length === 0) {
+    p.log.error('No syncable pieces found. Make sure you are in the project root.');
     process.exit(1);
   }
 
-  // ── 5. Restore stashed changes ────────────────────────────────────
-  const stashList = await git.stashList();
-  if (stashList.total > 0) {
-    const restoreSpinner = p.spinner();
-    restoreSpinner.start('Restoring your local changes...');
+  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.stash(['pop']);
-      restoreSpinner.stop(`${chalk.green('✓')} Local changes restored`);
+      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) {
-      restoreSpinner.stop(`${chalk.yellow('⚠')} Conflict restoring stash — resolve manually`);
-      p.log.warn(`Run ${chalk.cyan('git stash pop')} to restore your changes.`);
+      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!'));
 }
 
+// ── 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,
+      });
+    }
+  }
+
+  // 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 choices;
+}
+
 function cancel() {
   p.cancel('Cancelled.');
   process.exit(0);