create-epinoetics-app 1.0.3 → 1.0.6

package/bin/create-epinoetics-app.js

@@ -5,6 +5,7 @@ import { readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { run } from '../src/index.js';
+import { runAdd } from '../src/adder.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'));
@@ -12,21 +13,32 @@ const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8
 program
   .name('create-epinoetics-app')
   .description('Scaffold a new project from your boilerplate repos')
-  .version(pkg.version)
-  .argument('[project-name]', 'Name of the project to create')
+  .version(pkg.version);
+
+// ── create (default) ──────────────────────────────────────────────
+program
+  .command('create [project-name]', { isDefault: true })
+  .description('Scaffold a new project')
   .option('-b, --backend <id>',  'Backend to use: api-nest | api-dotnet')
   .option('-f, --frontend <id>', 'Frontend to use: web-next | web-astro (when available)')
   .option('--dry-run',           'Preview without cloning anything')
   .option('--yes',               'Skip confirmation prompt')
-  .parse(process.argv);
+  .action((projectName, opts) => {
+    run({
+      projectName,
+      backend:  opts.backend,
+      frontend: opts.frontend,
+      dryRun:   opts.dryRun  ?? false,
+      yes:      opts.yes     ?? false,
+    });
+  });
 
-const opts = program.opts();
-const [projectName] = program.args;
+// ── add ───────────────────────────────────────────────────────────
+program
+  .command('add')
+  .description('Add a feature to an existing project (run from code/api-nest)')
+  .action(() => {
+    runAdd();
+  });
 
-run({
-  projectName,
-  backend:  opts.backend,
-  frontend: opts.frontend,
-  dryRun:   opts.dryRun  ?? false,
-  yes:      opts.yes     ?? false,
-});
+program.parse(process.argv);

package/package.json

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

package/src/adder.js

@@ -0,0 +1,245 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { resolve, join } from 'path';
+import { simpleGit } from 'simple-git';
+import fs from 'fs';
+import os from 'os';
+import { NEST_FEATURES, NEST_DATABASES } from './repos.js';
+
+export async function runAdd() {
+  console.log('');
+  p.intro(
+    chalk.bgHex('#7c3aed').white(' create-epinoetics-app add ') +
+    chalk.dim(' add a feature to your project')
+  );
+
+  const cwd = process.cwd();
+
+  // ── 1. Read scaffold.config.json ──────────────────────────────────
+  const configPath = join(cwd, 'scaffold.config.json');
+  if (!fs.existsSync(configPath)) {
+    p.log.error(
+      'No scaffold.config.json found.\n' +
+      chalk.dim('Make sure you are inside the code/api-nest directory.')
+    );
+    process.exit(1);
+  }
+
+  const config   = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const database = NEST_DATABASES.find(d => d.id === config.database);
+
+  if (!database) {
+    p.log.error(`Unknown database "${config.database}" in scaffold.config.json.`);
+    process.exit(1);
+  }
+
+  // ── 2. Show only features not already installed ───────────────────
+  const installedIds  = new Set(config.features ?? []);
+  const available     = NEST_FEATURES.filter(f => !installedIds.has(f.id));
+
+  if (available.length === 0) {
+    p.outro(chalk.green('All available features are already installed!'));
+    return;
+  }
+
+  p.note(
+    [
+      `${chalk.dim('database '.padEnd(14))} ${chalk.cyan(database.label)}`,
+      `${chalk.dim('installed'.padEnd(14))} ${config.features.length ? config.features.map(f => chalk.cyan(f)).join(chalk.dim(', ')) : chalk.dim('none')}`,
+    ].join('\n'),
+    'Current project'
+  );
+
+  // ── 3. Pick features to add ───────────────────────────────────────
+  const featureIds = await p.multiselect({
+    message: 'Which features do you want to add?',
+    options: available.map(f => ({
+      value: f.id,
+      label: f.label,
+      hint:  f.hint,
+    })),
+    required: true,
+  });
+  if (p.isCancel(featureIds)) return cancel();
+
+  const toAdd = NEST_FEATURES.filter(f => featureIds.includes(f.id));
+
+  // ── 4. Confirm ────────────────────────────────────────────────────
+  const confirm = await p.confirm({
+    message: `Add ${toAdd.map(f => chalk.cyan(f.label)).join(', ')} to this project?`,
+  });
+  if (p.isCancel(confirm) || !confirm) return cancel();
+
+  // ── 5. Clone the db branch into a temp directory ──────────────────
+  const tmpDir  = join(os.tmpdir(), `epinoetics-add-${Date.now()}`);
+  const spinner = p.spinner();
+
+  spinner.start(`Fetching features from ${chalk.dim(database.branch)}...`);
+
+  try {
+    await simpleGit().clone(config.repoUrl, tmpDir, ['--branch', database.branch, '--single-branch', '--depth=1']);
+    spinner.stop(`${chalk.green('✓')} Fetched boilerplate`);
+  } catch (err) {
+    spinner.stop(`${chalk.red('✗')} Clone failed  ${chalk.dim(err.message)}`);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    process.exit(1);
+  }
+
+  // ── 6. Copy each feature folder into the project ──────────────────
+  for (const feature of toAdd) {
+    const srcDir  = join(tmpDir, 'src', 'features', feature.id);
+    const destDir = join(cwd, 'src', 'features', feature.id);
+
+    if (!fs.existsSync(srcDir)) {
+      p.log.warn(`Feature "${feature.id}" not found in repo — skipping.`);
+      continue;
+    }
+
+    if (fs.existsSync(destDir)) {
+      p.log.warn(`Feature "${feature.id}" already exists locally — skipping.`);
+      continue;
+    }
+
+    fs.cpSync(srcDir, destDir, { recursive: true });
+    p.log.step(`${chalk.green('✓')} Copied ${chalk.cyan(feature.label)}  ${chalk.dim(`→ src/features/${feature.id}`)}`);
+  }
+
+  // ── 7. Patch schema ───────────────────────────────────────────────
+  if (database.id === 'drizzle') {
+    addDrizzleExports({ cwd, tmpDir, toAdd });
+  } else if (database.id === 'prisma') {
+    addPrismaModels({ cwd, tmpDir, toAdd });
+  }
+
+  // ── 8. Patch app.module.ts ────────────────────────────────────────
+  addAppModuleImports({ cwd, toAdd });
+
+  // ── 9. Cleanup temp dir ───────────────────────────────────────────
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  // ── 10. Update scaffold.config.json ──────────────────────────────
+  config.features = [...new Set([...config.features, ...featureIds])];
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+  p.log.step(`Updated scaffold.config.json`);
+
+  p.outro(
+    chalk.green('Done!') + chalk.dim('  Run your migrations and you\'re good to go.')
+  );
+}
+
+// ── Drizzle: append export lines to schema.ts ─────────────────────
+function addDrizzleExports({ cwd, tmpDir, toAdd }) {
+  const candidates = [
+    join(cwd, 'src', 'database', 'schema.ts'),
+    join(cwd, 'src', 'db', 'schema.ts'),
+    join(cwd, 'src', 'schema.ts'),
+  ];
+
+  const schemaPath = candidates.find(f => fs.existsSync(f));
+  if (!schemaPath) {
+    p.log.warn('Could not find schema.ts — add exports manually.');
+    return;
+  }
+
+  // Get the export lines from the tmp clone's schema.ts
+  const tmpCandidates = [
+    join(tmpDir, 'src', 'database', 'schema.ts'),
+    join(tmpDir, 'src', 'db', 'schema.ts'),
+    join(tmpDir, 'src', 'schema.ts'),
+  ];
+
+  const tmpSchemaPath = tmpCandidates.find(f => fs.existsSync(f));
+  if (!tmpSchemaPath) return;
+
+  const tmpContent = fs.readFileSync(tmpSchemaPath, 'utf8');
+  let additions    = '';
+
+  for (const feature of toAdd) {
+    const pattern = new RegExp(
+      `^export \\* from ['"].*features\\/${feature.id}\\/.*['"];?$`,
+      'gm'
+    );
+    const matches = tmpContent.match(pattern);
+    if (matches) additions += matches.join('\n') + '\n';
+  }
+
+  if (additions) {
+    fs.appendFileSync(schemaPath, '\n' + additions, 'utf8');
+    p.log.step(`Updated schema.ts  ${chalk.dim(`(added ${toAdd.length} export line(s))`)}`);
+  }
+}
+
+// ── Prisma: append model blocks to schema.prisma ──────────────────
+function addPrismaModels({ cwd, tmpDir, toAdd }) {
+  const candidates = [
+    join(cwd, 'prisma', 'schema.prisma'),
+    join(cwd, 'schema.prisma'),
+  ];
+
+  const schemaPath = candidates.find(f => fs.existsSync(f));
+  if (!schemaPath) {
+    p.log.warn('Could not find schema.prisma — add models manually.');
+    return;
+  }
+
+  const tmpCandidates = [
+    join(tmpDir, 'prisma', 'schema.prisma'),
+    join(tmpDir, 'schema.prisma'),
+  ];
+
+  const tmpSchemaPath = tmpCandidates.find(f => fs.existsSync(f));
+  if (!tmpSchemaPath) return;
+
+  const tmpContent = fs.readFileSync(tmpSchemaPath, 'utf8');
+  let additions    = '';
+
+  for (const feature of toAdd) {
+    const pattern = new RegExp(
+      `\\/\\/ @feature:${feature.id}\\n[\\s\\S]*?\\/\\/ @endfeature:${feature.id}`,
+      'g'
+    );
+    const matches = tmpContent.match(pattern);
+    if (matches) additions += '\n' + matches.join('\n') + '\n';
+  }
+
+  if (additions) {
+    fs.appendFileSync(schemaPath, additions, 'utf8');
+    p.log.step(`Updated schema.prisma  ${chalk.dim(`(added ${toAdd.length} model block(s))`)}`);
+  }
+}
+
+// ── Add import + module to app.module.ts ──────────────────────────
+function addAppModuleImports({ cwd, toAdd }) {
+  const appModulePath = join(cwd, 'src', 'app.module.ts');
+  if (!fs.existsSync(appModulePath)) {
+    p.log.warn('Could not find app.module.ts — add imports manually.');
+    return;
+  }
+
+  let content = fs.readFileSync(appModulePath, 'utf8');
+
+  for (const feature of toAdd) {
+    const moduleName = feature.id.charAt(0).toUpperCase() + feature.id.slice(1) + 'Module';
+
+    // Add import line after the last existing import
+    const importLine = `import { ${moduleName} } from './features/${feature.id}/${feature.id}.module';`;
+    content = content.replace(
+      /(import [^\n]+\n)(?!import)/,
+      `$1${importLine}\n`
+    );
+
+    // Add module to imports array before ConfigModule
+    content = content.replace(
+      /(\/\/ internal\n)/,
+      `$1    ${moduleName},\n`
+    );
+  }
+
+  fs.writeFileSync(appModulePath, content, 'utf8');
+  p.log.step(`Updated app.module.ts  ${chalk.dim(`(added ${toAdd.length} module(s))`)}`);
+}
+
+function cancel() {
+  p.cancel('Cancelled.');
+  process.exit(0);
+}

package/src/cloner.js

@@ -64,18 +64,47 @@ export async function cloneAndMergeNest({ projectName, database, selectedFeature
     );
   }
 
-  // 3. Prune schema.ts — remove export lines for deleted features
-  pruneSchema({ dest, toRemove });
+  // 3. Prune schema — Drizzle or Prisma
+  if (database.id === 'drizzle') {
+    pruneDrizzleSchema({ dest, toRemove });
+  } else if (database.id === 'prisma') {
+    prunePrismaSchema({ dest, toRemove });
+  }
 
-  // 4. Prune app.module.ts — remove imports and module references
+  // 4. Prune app.module.ts
   pruneAppModule({ dest, toRemove });
 
-  // 5. Strip .git
+  // 5. Remove migrations directory
+  pruneMigrations({ dest, database });
+
+  // 6. Write scaffold.config.json
+  writeScaffoldConfig({ dest, database, selectedFeatures, repoUrl });
+
+  // 7. Strip .git
   fs.rmSync(join(dest, '.git'), { recursive: true, force: true });
 }
 
-// ── Remove export * lines from schema.ts for deleted features ─────
-function pruneSchema({ dest, toRemove }) {
+// ── Write scaffold.config.json ────────────────────────────────────
+function writeScaffoldConfig({ dest, database, selectedFeatures, repoUrl }) {
+  const config = {
+    database:  database.id,
+    branch:    database.branch,
+    features:  selectedFeatures.map(f => f.id),
+    repoUrl,
+    createdAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(
+    join(dest, 'scaffold.config.json'),
+    JSON.stringify(config, null, 2),
+    'utf8'
+  );
+
+  p.log.step(`Written scaffold.config.json`);
+}
+
+// ── Drizzle: remove export * lines from schema.ts ─────────────────
+function pruneDrizzleSchema({ dest, toRemove }) {
   if (toRemove.length === 0) return;
 
   const candidates = [
@@ -94,7 +123,6 @@ function pruneSchema({ dest, toRemove }) {
   const before = content;
 
   for (const feature of toRemove) {
-    // Removes: export * from '../features/posts/post.schema';
     const pattern = new RegExp(
       `^export \\* from ['"].*features\\/${feature.id}\\/.*['"];?\\n?`,
       'gm'
@@ -108,6 +136,38 @@ function pruneSchema({ dest, toRemove }) {
   }
 }
 
+// ── Prisma: remove model blocks from schema.prisma ────────────────
+function prunePrismaSchema({ dest, toRemove }) {
+  if (toRemove.length === 0) return;
+
+  const candidates = [
+    join(dest, 'prisma', 'schema.prisma'),
+    join(dest, 'schema.prisma'),
+  ];
+
+  const schemaPath = candidates.find(f => fs.existsSync(f));
+  if (!schemaPath) {
+    p.log.warn('Could not find schema.prisma — remove unused models manually.');
+    return;
+  }
+
+  let content  = fs.readFileSync(schemaPath, 'utf8');
+  const before = content;
+
+  for (const feature of toRemove) {
+    const pattern = new RegExp(
+      `\\/\\/ @feature:${feature.id}\\n[\\s\\S]*?\\/\\/ @endfeature:${feature.id}\\n?`,
+      'g'
+    );
+    content = content.replace(pattern, '');
+  }
+
+  if (content !== before) {
+    fs.writeFileSync(schemaPath, content, 'utf8');
+    p.log.step(`Pruned schema.prisma  ${chalk.dim(`(removed ${toRemove.length} model block(s))`)}`);
+  }
+}
+
 // ── Remove import + Module reference from app.module.ts ───────────
 function pruneAppModule({ dest, toRemove }) {
   if (toRemove.length === 0) return;
@@ -122,21 +182,14 @@ function pruneAppModule({ dest, toRemove }) {
   const before = content;
 
   for (const feature of toRemove) {
-    // Derive the module class name from the feature id:
-    // e.g. posts → PostsModule, seo → SeoModule
     const moduleName = feature.id.charAt(0).toUpperCase() + feature.id.slice(1) + 'Module';
 
-    // Remove the import line:
-    // import { PostsModule } from './features/posts/posts.module';
     const importPattern = new RegExp(
       `^import \\{[^}]*${moduleName}[^}]*\\} from ['"].*features\\/${feature.id}\\/.*['"];?\\n?`,
       'gm'
     );
     content = content.replace(importPattern, '');
 
-    // Remove the module from the imports array:
-    // PostsModule, (with optional trailing comma + whitespace/newline)
-    // or ,PostsModule (preceded by comma)
     const refPattern = new RegExp(
       `\\n?\\s*${moduleName},?|,?\\s*${moduleName}`,
       'g'
@@ -148,4 +201,18 @@ function pruneAppModule({ dest, toRemove }) {
     fs.writeFileSync(appModulePath, content, 'utf8');
     p.log.step(`Pruned app.module.ts  ${chalk.dim(`(removed ${toRemove.length} module(s))`)}`);
   }
+}
+
+// ── Remove migrations directory ───────────────────────────────────
+function pruneMigrations({ dest, database }) {
+  const candidates = database.id === 'drizzle'
+    ? [join(dest, 'migrations'), join(dest, 'drizzle')]
+    : [join(dest, 'prisma', 'migrations')];
+
+  for (const dir of candidates) {
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+      p.log.step(`Removed migrations  ${chalk.dim(dir.replace(dest, ''))}`);
+    }
+  }
 }

package/src/index.js

@@ -42,7 +42,6 @@ export async function run(flags) {
   let features = [];
 
   if (backendId === 'api-nest') {
-    // Database
     const dbId = await p.select({
       message: 'Database',
       options: NEST_DATABASES.map(d => ({
@@ -54,7 +53,6 @@ export async function run(flags) {
     if (p.isCancel(dbId)) return cancel();
     database = NEST_DATABASES.find(d => d.id === dbId);
 
-    // Features
     const featureIds = await p.multiselect({
       message: 'Features  (space to select, enter to confirm)',
       options: NEST_FEATURES.map(f => ({
@@ -141,20 +139,17 @@ export async function run(flags) {
 function buildPlainRepos({ backendId, frontendId }) {
   const list = [];
 
-  // Dashboard — always included
   for (const group of Object.values(REPOS)) {
     for (const repo of group) {
       if (repo.fixed) list.push(repo);
     }
   }
 
-  // .NET (NestJS is handled separately)
   if (backendId === 'api-dotnet') {
     const dotnet = REPOS.backend.find(r => r.id === 'api-dotnet');
     if (dotnet) list.push(dotnet);
   }
 
-  // Frontend
   if (frontendId && REPOS.frontend) {
     const frontend = REPOS.frontend.find(r => r.id === frontendId);
     if (frontend) list.push(frontend);