create-epinoetics-app 1.0.7 → 1.0.8

package/package.json

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

package/src/cloner.js

@@ -80,26 +80,28 @@ export async function cloneAndMergeNest({ projectName, database, selectedFeature
   // 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. Strip boilerplate .git and init a fresh one
+  await initFreshGit({ dest });
 }
 
-// ── 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`);
+// ── 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)}`);
+  }
 }
 
 // ── Write scaffold.config.json ────────────────────────────────────

package/src/syncer.js

@@ -4,6 +4,17 @@ import { join } from 'path';
 import { simpleGit } from 'simple-git';
 import { NEST_DATABASES } 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('');
@@ -32,65 +43,96 @@ export async function runSync() {
       `${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'
+    'Syncing from boilerplate'
   );
 
   const confirm = await p.confirm({
-    message: `Pull latest changes from ${chalk.cyan(config.branch)}?`,
+    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. Make sure .git exists ──────────────────────────────────────
-  const gitDir = join(cwd, '.git');
-  if (!fs.existsSync(gitDir)) {
-    p.log.error(
-      '.git directory not found.\n' +
-      chalk.dim('Re-scaffold this project to enable sync.')
-    );
-    process.exit(1);
-  }
-
-  // ── 3. Stash any local changes ────────────────────────────────────
-  const git     = simpleGit(cwd);
+  // ── 2. Clone latest into temp dir ─────────────────────────────────
+  const tmpDir  = join(os.tmpdir(), `epinoetics-sync-${Date.now()}`);
   const spinner = p.spinner();
 
-  spinner.start('Stashing local changes...');
+  spinner.start(`Fetching latest from ${chalk.dim(config.branch)}...`);
+
   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'));
+    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 });
+    process.exit(1);
   }
 
-  // ── 4. Pull latest from the db branch ────────────────────────────
-  const pullSpinner = p.spinner();
-  pullSpinner.start(`Pulling latest from ${chalk.cyan(config.branch)}...`);
+  // ── 3. Copy changed files, skipping protected paths ───────────────
+  const copySpinner = p.spinner();
+  copySpinner.start('Applying updates...');
+
+  let updated = 0;
 
   try {
-    await git.pull('origin', config.branch, ['--rebase']);
-    pullSpinner.stop(`${chalk.green('✓')} Pulled latest changes`);
+    updated = syncDirs({ src: tmpDir, dest: cwd });
+    copySpinner.stop(`${chalk.green('✓')} Applied updates  ${chalk.dim(`(${updated} file(s) updated)`)}`);
   } catch (err) {
-    pullSpinner.stop(`${chalk.red('✗')} Pull failed  ${chalk.dim(err.message)}`);
-    p.log.warn('Restoring your stashed changes...');
-    await git.stash(['pop']).catch(() => {});
+    copySpinner.stop(`${chalk.red('✗')} Sync failed  ${chalk.dim(err.message)}`);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
     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...');
-    try {
-      await git.stash(['pop']);
-      restoreSpinner.stop(`${chalk.green('✓')} Local changes restored`);
-    } catch (err) {
-      restoreSpinner.stop(`${chalk.yellow('⚠')} Conflict restoring stash — resolve manually`);
-      p.log.warn(`Run ${chalk.cyan('git stash pop')} to restore your changes.`);
+  // ── 4. Cleanup temp dir ───────────────────────────────────────────
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  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.')
+  );
+}
+
+// ── 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;
+
+      // Only write if file changed
+      if (!destContent || !srcContent.equals(destContent)) {
+        fs.writeFileSync(destPath, srcContent);
+        count++;
+      }
     }
   }
 
-  p.outro(chalk.green('Sync complete!'));
+  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)
+  );
 }
 
 function cancel() {