deepspace 0.4.5 → 0.5.1

package/scripts/add-feature.cjs

@@ -8,30 +8,32 @@
  * Invoked by the `deepspace add` CLI in src/cli/commands/add.ts.
  */
 
-const fs = require('fs');
-const path = require('path');
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- CommonJS (.cjs) module: require is required
+const fs = require('fs')
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- CommonJS (.cjs) module: require is required
+const path = require('path')
 
 // ---------------------------------------------------------------------------
 // Environment-aware features path resolution
 // ---------------------------------------------------------------------------
 
 function findFeaturesDir() {
-  const candidate = path.resolve(__dirname, '..', 'features');
-  if (fs.existsSync(candidate)) return candidate;
-  console.error('Error: Could not find features directory at ' + candidate);
-  process.exit(1);
+  const candidate = path.resolve(__dirname, '..', 'features')
+  if (fs.existsSync(candidate)) return candidate
+  console.error('Error: Could not find features directory at ' + candidate)
+  process.exit(1)
 }
 
-const FEATURES_DIR = findFeaturesDir();
+const FEATURES_DIR = findFeaturesDir()
 
 // ---------------------------------------------------------------------------
 // Resolve target directory
 // ---------------------------------------------------------------------------
 
 function resolveTargetDir(raw) {
-  if (!raw) return null;
-  if (path.isAbsolute(raw)) return raw;
-  return path.resolve(raw);
+  if (!raw) return null
+  if (path.isAbsolute(raw)) return raw
+  return path.resolve(raw)
 }
 
 // ---------------------------------------------------------------------------
@@ -45,116 +47,127 @@ const CATEGORY_LABELS = {
   layout: 'Layouts',
   display: 'Display',
   landing: 'Landing Page Sections',
-};
+}
 
-const CATEGORY_ORDER = ['assistant', 'data', 'nav', 'layout', 'display', 'landing'];
+const CATEGORY_ORDER = ['assistant', 'data', 'nav', 'layout', 'display', 'landing']
 
 // ---------------------------------------------------------------------------
 // Core helpers
 // ---------------------------------------------------------------------------
 
 function loadFeatureConfig(featureId) {
-  const configPath = path.join(FEATURES_DIR, featureId, 'feature.json');
-  if (!fs.existsSync(configPath)) return null;
+  const configPath = path.join(FEATURES_DIR, featureId, 'feature.json')
+  if (!fs.existsSync(configPath)) return null
   try {
-    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
   } catch (e) {
-    console.error(`Error reading ${configPath}:`, e.message);
-    return null;
+    console.error(`Error reading ${configPath}:`, e.message)
+    return null
   }
 }
 
 function listFeatures() {
-  const entries = fs.readdirSync(FEATURES_DIR, { withFileTypes: true });
-  const configs = [];
+  const entries = fs.readdirSync(FEATURES_DIR, { withFileTypes: true })
+  const configs = []
   for (const e of entries) {
     if (e.isDirectory() && e.name !== 'scripts') {
-      const config = loadFeatureConfig(e.name);
-      if (config) configs.push(config);
+      const config = loadFeatureConfig(e.name)
+      // Internal features (e2e/QA fixtures) are installable by explicit name
+      // but hidden from `--list` and the interactive picker.
+      if (config && !config.internal) configs.push(config)
     }
   }
-  return configs;
+  return configs
 }
 
 function groupByCategory(features) {
-  const groups = new Map();
+  const groups = new Map()
   for (const f of features) {
-    const category = f.category || 'other';
-    if (!groups.has(category)) groups.set(category, []);
-    groups.get(category).push(f);
+    const category = f.category || 'other'
+    if (!groups.has(category)) groups.set(category, [])
+    groups.get(category).push(f)
   }
-  return groups;
+  return groups
 }
 
 function copyFile(src, dest) {
-  const destDir = path.dirname(dest);
-  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
-  fs.copyFileSync(src, dest);
+  const destDir = path.dirname(dest)
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true })
+  fs.copyFileSync(src, dest)
 }
 
 // Copy + rewrite leading `../` imports. Used when a page file is redirected
-// into src/pages/(protected)/, which adds one directory level — every relative
-// import that traverses upward needs one extra `../`. Matches static
-// `from '...'`, side-effect `import '...'`, and dynamic/type `import('...')`
-// (e.g. `import('../hooks/x').T` in a type position, or `await import('../x')`).
+// into a deeper route group (e.g. src/pages/(app)/ adds one directory level,
+// src/pages/(app)/(protected)/ adds two) — every relative import that
+// traverses upward needs `levels` extra `../`. Matches static `from '...'`,
+// side-effect `import '...'`, and dynamic/type `import('...')` (e.g.
+// `import('../hooks/x').T` in a type position, or `await import('../x')`).
 // Same-directory (`./...`) and bare-package imports are untouched.
-function copyFileWithImportShift(src, dest) {
-  const destDir = path.dirname(dest);
-  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
-  const content = fs.readFileSync(src, 'utf-8');
-  const shifted = content.replace(/(from\s+|import\s+|import\()(['"])\.\.\//g, '$1$2../../');
-  fs.writeFileSync(dest, shifted);
+function copyFileWithImportShift(src, dest, levels) {
+  const destDir = path.dirname(dest)
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true })
+  const content = fs.readFileSync(src, 'utf-8')
+  const prefix = '../'.repeat(levels)
+  const shifted = content.replace(/(from\s+|import\s+|import\()(['"])(\.\.\/)/g, `$1$2${prefix}$3`)
+  fs.writeFileSync(dest, shifted)
 }
 
 // ---------------------------------------------------------------------------
 // Install files
 // ---------------------------------------------------------------------------
 
-// When a feature's route is protected, page files must land under
-// src/pages/(protected)/ so generouted's route group wraps them in <AuthGate>.
-// `(protected)` is a folder-name-only group — the URL path is unchanged.
-// Only page files (src/pages/*) get rewritten; schemas, components, etc.
-// keep their declared destinations.
+// Page files must land under src/pages/(app)/ so the (app)/_layout.tsx route
+// group wraps them in the DeepSpace providers (auth + realtime records) — the
+// top level of src/pages/ is reserved for static pages that mount no
+// providers. Protected pages go one level deeper, under (app)/(protected)/,
+// so the nested layout also wraps them in <AuthGate>. Both are
+// folder-name-only route groups — the URL path is unchanged. Only page files
+// (src/pages/*) get redirected; schemas, components, etc. keep their declared
+// destinations. Page files already placed in the (app) group are left as-is.
 function resolveDestPath(fileDest, route) {
-  const PAGES = 'src/pages/';
-  const PROTECTED = 'src/pages/(protected)/';
-  const isProtected = route && route.protected !== false;
-  if (!isProtected) return fileDest;
-  if (!fileDest.startsWith(PAGES) || fileDest.startsWith(PROTECTED)) return fileDest;
-  return PROTECTED + fileDest.slice(PAGES.length);
+  const PAGES = 'src/pages/'
+  const APP = 'src/pages/(app)/'
+  if (!fileDest.startsWith(PAGES) || fileDest.startsWith(APP)) return fileDest
+  const rest = fileDest.slice(PAGES.length)
+  const isProtected = route && route.protected !== false
+  return isProtected ? `${APP}(protected)/${rest}` : `${APP}${rest}`
 }
 
 function installFeature(config, targetDir) {
-  let copied = 0;
-  let skipped = 0;
+  let copied = 0
+  let skipped = 0
 
   for (const file of config.files) {
-    const srcPath = path.join(FEATURES_DIR, config.id, file.src);
-    const resolvedDest = resolveDestPath(file.dest, config.route);
-    const destPath = path.join(targetDir, resolvedDest);
-    const wasRedirected = resolvedDest !== file.dest;
+    const srcPath = path.join(FEATURES_DIR, config.id, file.src)
+    const resolvedDest = resolveDestPath(file.dest, config.route)
+    const destPath = path.join(targetDir, resolvedDest)
+    const wasRedirected = resolvedDest !== file.dest
+    // Each extra path segment in the resolved dest is one directory level the
+    // page dropped into (e.g. (app)/ = 1, (app)/(protected)/ = 2), which is
+    // exactly how many `../` its upward relative imports must gain.
+    const shiftLevels = resolvedDest.split('/').length - file.dest.split('/').length
 
     if (!fs.existsSync(srcPath)) {
-      console.error(`   Warning: source not found: ${file.src}`);
-      continue;
+      console.error(`   Warning: source not found: ${file.src}`)
+      continue
     }
 
     if (fs.existsSync(destPath) && !file.overwrite) {
-      console.log(`   Exists (skipped): ${resolvedDest}`);
-      skipped++;
+      console.log(`   Exists (skipped): ${resolvedDest}`)
+      skipped++
     } else {
-      const replacing = fs.existsSync(destPath);
+      const replacing = fs.existsSync(destPath)
       if (wasRedirected) {
-        copyFileWithImportShift(srcPath, destPath);
+        copyFileWithImportShift(srcPath, destPath, shiftLevels)
       } else {
-        copyFile(srcPath, destPath);
+        copyFile(srcPath, destPath)
       }
-      console.log(`   ${replacing ? 'Overwrote' : 'Copied'}: ${resolvedDest}`);
-      copied++;
+      console.log(`   ${replacing ? 'Overwrote' : 'Copied'}: ${resolvedDest}`)
+      copied++
     }
   }
 
-  return { copied, skipped };
+  return { copied, skipped }
 }
 
 // ---------------------------------------------------------------------------
@@ -162,72 +175,72 @@ function installFeature(config, targetDir) {
 // ---------------------------------------------------------------------------
 
 function integrateSchema(config, targetDir) {
-  if (!config.schema) return false;
+  if (!config.schema) return false
 
-  const schemasPath = path.join(targetDir, 'src', 'schemas.ts');
+  const schemasPath = path.join(targetDir, 'src', 'schemas.ts')
   if (!fs.existsSync(schemasPath)) {
-    printSchemaInstructions(config.schema);
-    return false;
+    printSchemaInstructions(config.schema)
+    return false
   }
 
-  let content = fs.readFileSync(schemasPath, 'utf-8');
-  const { exportName, importPath, spreadOperator } = config.schema;
+  let content = fs.readFileSync(schemasPath, 'utf-8')
+  const { exportName, importPath, spreadOperator } = config.schema
 
   // Already integrated?
-  const importPattern = new RegExp(`^import\\s+\\{[^}]*\\b${exportName}\\b`, 'm');
+  const importPattern = new RegExp(`^import\\s+\\{[^}]*\\b${exportName}\\b`, 'm')
   if (importPattern.test(content)) {
-    console.log(`   Schema already present: ${exportName}`);
-    return false;
+    console.log(`   Schema already present: ${exportName}`)
+    return false
   }
 
   // Strict checks: verify the file has the expected structure
-  const hasExportConst = content.includes('export const schemas');
-  const hasArrayOpening = /export const schemas:\s*CollectionSchema\[\]\s*=\s*\[/.test(content);
+  const hasExportConst = content.includes('export const schemas')
+  const hasArrayOpening = /export const schemas:\s*CollectionSchema\[\]\s*=\s*\[/.test(content)
 
   if (!hasExportConst || !hasArrayOpening) {
-    console.log('   Could not auto-integrate schema (schemas.ts has unexpected structure)');
-    printSchemaInstructions(config.schema);
-    return false;
+    console.log('   Could not auto-integrate schema (schemas.ts has unexpected structure)')
+    printSchemaInstructions(config.schema)
+    return false
   }
 
   // 1. Add import before "export const schemas"
-  const importLine = `import { ${exportName} } from '${importPath}'`;
+  const importLine = `import { ${exportName} } from '${importPath}'`
   const afterImport = content.replace(
     /export const schemas/,
-    `${importLine}\n\nexport const schemas`
-  );
+    `${importLine}\n\nexport const schemas`,
+  )
 
   if (afterImport === content) {
-    console.log('   Could not insert import line');
-    printSchemaInstructions(config.schema);
-    return false;
+    console.log('   Could not insert import line')
+    printSchemaInstructions(config.schema)
+    return false
   }
 
   // 2. Insert entry into the schemas array
-  const schemaEntry = spreadOperator ? `...${exportName}` : exportName;
+  const schemaEntry = spreadOperator ? `...${exportName}` : exportName
   const afterEntry = afterImport.replace(
     /export const schemas:\s*CollectionSchema\[\]\s*=\s*\[/,
-    `export const schemas: CollectionSchema[] = [\n  ${schemaEntry},`
-  );
+    `export const schemas: CollectionSchema[] = [\n  ${schemaEntry},`,
+  )
 
   if (afterEntry === afterImport) {
-    console.log('   Could not insert schema entry');
-    printSchemaInstructions(config.schema);
-    return false;
+    console.log('   Could not insert schema entry')
+    printSchemaInstructions(config.schema)
+    return false
   }
 
-  fs.writeFileSync(schemasPath, afterEntry);
-  console.log(`   Schema integrated: ${exportName} -> schemas.ts`);
-  return true;
+  fs.writeFileSync(schemasPath, afterEntry)
+  console.log(`   Schema integrated: ${exportName} -> schemas.ts`)
+  return true
 }
 
 function printSchemaInstructions(schema) {
-  const { exportName, importPath, spreadOperator } = schema;
-  const entry = spreadOperator ? `...${exportName}` : exportName;
-  console.log('');
-  console.log('   Add manually to src/schemas.ts:');
-  console.log(`     import { ${exportName} } from '${importPath}'`);
-  console.log(`     // then add ${entry} to the schemas array`);
+  const { exportName, importPath, spreadOperator } = schema
+  const entry = spreadOperator ? `...${exportName}` : exportName
+  console.log('')
+  console.log('   Add manually to src/schemas.ts:')
+  console.log(`     import { ${exportName} } from '${importPath}'`)
+  console.log(`     // then add ${entry} to the schemas array`)
 }
 
 // ---------------------------------------------------------------------------
@@ -235,76 +248,77 @@ function printSchemaInstructions(schema) {
 // ---------------------------------------------------------------------------
 
 function integrateActions(config, targetDir) {
-  if (!config.actions || config.actions.length === 0) return false;
+  if (!config.actions || config.actions.length === 0) return false
 
-  const actionsPath = path.join(targetDir, 'src', 'actions', 'index.ts');
+  const actionsPath = path.join(targetDir, 'src', 'actions', 'index.ts')
   if (!fs.existsSync(actionsPath)) {
-    printActionsInstructions(config.actions);
-    return false;
+    printActionsInstructions(config.actions)
+    return false
   }
 
-  let content = fs.readFileSync(actionsPath, 'utf-8');
+  let content = fs.readFileSync(actionsPath, 'utf-8')
 
   // Strict check: must match the starter's shape so our regex patch is safe.
   // Accepts both `ActionHandler` and `ActionHandler<Env>` (typed-env templates).
-  const hasRegistry = /export const actions:\s*Record<string,\s*ActionHandler(?:<[^>]*>)?>\s*=\s*\{/.test(content);
+  const hasRegistry =
+    /export const actions:\s*Record<string,\s*ActionHandler(?:<[^>]*>)?>\s*=\s*\{/.test(content)
   if (!hasRegistry) {
-    console.log('   Could not auto-integrate actions (actions/index.ts has unexpected structure)');
-    printActionsInstructions(config.actions);
-    return false;
+    console.log('   Could not auto-integrate actions (actions/index.ts has unexpected structure)')
+    printActionsInstructions(config.actions)
+    return false
   }
 
-  let integrated = 0;
+  let integrated = 0
   for (const action of config.actions) {
-    const { exportName, registerAs, importPath } = action;
+    const { exportName, registerAs, importPath } = action
 
     // Already integrated?
-    const importPattern = new RegExp(`^import\\s+\\{[^}]*\\b${exportName}\\b`, 'm');
+    const importPattern = new RegExp(`^import\\s+\\{[^}]*\\b${exportName}\\b`, 'm')
     if (importPattern.test(content)) {
-      console.log(`   Action already present: ${registerAs}`);
-      continue;
+      console.log(`   Action already present: ${registerAs}`)
+      continue
     }
 
     // 1. Add import before the registry export.
-    const importLine = `import { ${exportName} } from '${importPath}'`;
+    const importLine = `import { ${exportName} } from '${importPath}'`
     const withImport = content.replace(
       /export const actions:/,
       `${importLine}\n\nexport const actions:`,
-    );
+    )
     if (withImport === content) {
-      console.log(`   Could not insert import for ${exportName}`);
-      continue;
+      console.log(`   Could not insert import for ${exportName}`)
+      continue
     }
 
     // 2. Insert entry into the registry object. Works for both empty and
     //    populated registries because we inject right after the opening brace.
-    const registryEntry = `  '${registerAs}': ${exportName},`;
+    const registryEntry = `  '${registerAs}': ${exportName},`
     const withEntry = withImport.replace(
       /export const actions:\s*Record<string,\s*ActionHandler(?:<[^>]*>)?>\s*=\s*\{/,
       (match) => `${match}\n${registryEntry}`,
-    );
+    )
     if (withEntry === withImport) {
-      console.log(`   Could not insert registry entry for ${registerAs}`);
-      continue;
+      console.log(`   Could not insert registry entry for ${registerAs}`)
+      continue
     }
 
-    content = withEntry;
-    integrated++;
-    console.log(`   Action integrated: ${registerAs} (${exportName})`);
+    content = withEntry
+    integrated++
+    console.log(`   Action integrated: ${registerAs} (${exportName})`)
   }
 
   if (integrated > 0) {
-    fs.writeFileSync(actionsPath, content);
+    fs.writeFileSync(actionsPath, content)
   }
-  return integrated > 0;
+  return integrated > 0
 }
 
 function printActionsInstructions(actions) {
-  console.log('');
-  console.log('   Add manually to src/actions/index.ts:');
+  console.log('')
+  console.log('   Add manually to src/actions/index.ts:')
   for (const a of actions) {
-    console.log(`     import { ${a.exportName} } from '${a.importPath}'`);
-    console.log(`     // then add '${a.registerAs}': ${a.exportName} to the actions object`);
+    console.log(`     import { ${a.exportName} } from '${a.importPath}'`)
+    console.log(`     // then add '${a.registerAs}': ${a.exportName} to the actions object`)
   }
 }
 
@@ -313,98 +327,98 @@ function printActionsInstructions(actions) {
 // ---------------------------------------------------------------------------
 
 function integrateCss(config, targetDir) {
-  if (!config.css || config.css.length === 0) return false;
+  if (!config.css || config.css.length === 0) return false
 
-  const stylesPath = path.join(targetDir, 'src', 'styles.css');
+  const stylesPath = path.join(targetDir, 'src', 'styles.css')
   if (!fs.existsSync(stylesPath)) {
-    console.log('   Warning: Cannot integrate CSS — src/styles.css not found');
-    return false;
+    console.log('   Warning: Cannot integrate CSS — src/styles.css not found')
+    return false
   }
 
-  let stylesContent = fs.readFileSync(stylesPath, 'utf-8');
-  let integrated = 0;
+  let stylesContent = fs.readFileSync(stylesPath, 'utf-8')
+  let integrated = 0
 
   for (const cssFile of config.css) {
-    const srcPath = path.join(FEATURES_DIR, config.id, cssFile);
+    const srcPath = path.join(FEATURES_DIR, config.id, cssFile)
     if (!fs.existsSync(srcPath)) {
-      console.error(`   Warning: CSS source not found: ${cssFile}`);
-      continue;
+      console.error(`   Warning: CSS source not found: ${cssFile}`)
+      continue
     }
 
-    const cssContent = fs.readFileSync(srcPath, 'utf-8');
+    const cssContent = fs.readFileSync(srcPath, 'utf-8')
 
     // Check if already integrated by looking for a unique class/keyframe from the CSS
     // Use the first non-comment, non-empty line with a class or keyframe as fingerprint
-    const fingerprint = cssContent.match(/\.([\w-]+)\s*\{|@keyframes\s+([\w-]+)/);
+    const fingerprint = cssContent.match(/\.([\w-]+)\s*\{|@keyframes\s+([\w-]+)/)
     if (fingerprint) {
-      const marker = fingerprint[1] || fingerprint[2];
+      const marker = fingerprint[1] || fingerprint[2]
       if (stylesContent.includes(marker)) {
-        console.log(`   CSS already present: ${cssFile} (found .${marker})`);
-        continue;
+        console.log(`   CSS already present: ${cssFile} (found .${marker})`)
+        continue
       }
     }
 
-    stylesContent += '\n' + cssContent;
-    integrated++;
-    console.log(`   CSS integrated: ${cssFile} -> styles.css`);
+    stylesContent += '\n' + cssContent
+    integrated++
+    console.log(`   CSS integrated: ${cssFile} -> styles.css`)
   }
 
   if (integrated > 0) {
-    fs.writeFileSync(stylesPath, stylesContent);
+    fs.writeFileSync(stylesPath, stylesContent)
   }
 
-  return integrated > 0;
+  return integrated > 0
 }
 
 // ---------------------------------------------------------------------------
 // Nav auto-wiring into nav.ts
 // ---------------------------------------------------------------------------
 
-const NAV_MARKER = '// ── Features add nav items below this line ──';
+const NAV_MARKER = '// ── Features add nav items below this line ──'
 
 function integrateRoute(config, targetDir) {
-  if (!config.route) return false;
+  if (!config.route) return false
 
-  const navPath = path.join(targetDir, 'src', 'nav.ts');
+  const navPath = path.join(targetDir, 'src', 'nav.ts')
   if (!fs.existsSync(navPath)) {
-    printRouteInstructions(config.route, config);
-    return false;
+    printRouteInstructions(config.route, config)
+    return false
   }
 
-  let content = fs.readFileSync(navPath, 'utf-8');
-  const { path: routePath } = config.route;
-  const label = config.name;
+  let content = fs.readFileSync(navPath, 'utf-8')
+  const { path: routePath } = config.route
+  const label = config.name
 
   // Already wired?
   if (content.includes(`'${routePath}'`)) {
-    console.log(`   Nav already present: ${routePath}`);
-    return false;
+    console.log(`   Nav already present: ${routePath}`)
+    return false
   }
 
   if (!content.includes(NAV_MARKER)) {
-    console.log('   Could not auto-wire nav (marker not found in nav.ts)');
-    printRouteInstructions(config.route, config);
-    return false;
+    console.log('   Could not auto-wire nav (marker not found in nav.ts)')
+    printRouteInstructions(config.route, config)
+    return false
   }
 
-  const rolesStr = config.route.protected === false ? '' : ", roles: ['member' as Role]";
-  const entry = `  { path: '${routePath}', label: '${label}'${rolesStr} },`;
+  const rolesStr = config.route.protected === false ? '' : ", roles: ['member' as Role]"
+  const entry = `  { path: '${routePath}', label: '${label}'${rolesStr} },`
 
-  content = content.replace(NAV_MARKER, `${NAV_MARKER}\n${entry}`);
-  fs.writeFileSync(navPath, content);
-  console.log(`   Nav wired: ${routePath} (${label})`);
+  content = content.replace(NAV_MARKER, `${NAV_MARKER}\n${entry}`)
+  fs.writeFileSync(navPath, content)
+  console.log(`   Nav wired: ${routePath} (${label})`)
 
   // Route is automatic via generouted — page file in src/pages/ is enough
-  console.log(`   Route: automatic (file-based routing via src/pages/)`);
-  return true;
+  console.log(`   Route: automatic (file-based routing via src/pages/)`)
+  return true
 }
 
 function printRouteInstructions(route, config) {
-  const { path: routePath } = route;
-  const label = config?.name ?? routePath;
-  console.log('');
-  console.log('   Add manually to src/nav.ts:');
-  console.log(`     { path: '${routePath}', label: '${label}' },`);
+  const { path: routePath } = route
+  const label = config?.name ?? routePath
+  console.log('')
+  console.log('   Add manually to src/nav.ts:')
+  console.log(`     { path: '${routePath}', label: '${label}' },`)
 }
 
 // ---------------------------------------------------------------------------
@@ -427,58 +441,56 @@ function integrateDependencies(config, targetDir) {
   const sections = [
     { key: 'dependencies', label: 'dependencies' },
     { key: 'devDependencies', label: 'devDependencies' },
-  ];
+  ]
 
   // Skip the work if nothing is declared.
-  const hasAny = sections.some(
-    (s) => config[s.key] && Object.keys(config[s.key]).length > 0,
-  );
-  if (!hasAny) return;
+  const hasAny = sections.some((s) => config[s.key] && Object.keys(config[s.key]).length > 0)
+  if (!hasAny) return
 
-  const pkgPath = path.join(targetDir, 'package.json');
+  const pkgPath = path.join(targetDir, 'package.json')
   if (!fs.existsSync(pkgPath)) {
-    console.log('   Could not patch package.json (file not found)');
-    return;
+    console.log('   Could not patch package.json (file not found)')
+    return
   }
 
-  let pkg;
+  let pkg
   try {
-    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
   } catch (err) {
-    console.log(`   Could not patch package.json (parse error: ${err.message})`);
-    return;
+    console.log(`   Could not patch package.json (parse error: ${err.message})`)
+    return
   }
 
-  const added = [];
-  const skipped = [];
+  const added = []
+  const skipped = []
 
   for (const { key } of sections) {
-    const declared = config[key];
-    if (!declared) continue;
-    pkg[key] = pkg[key] || {};
+    const declared = config[key]
+    if (!declared) continue
+    pkg[key] = pkg[key] || {}
     for (const [name, version] of Object.entries(declared)) {
       if (pkg[key][name]) {
-        skipped.push(name);
-        continue;
+        skipped.push(name)
+        continue
       }
-      pkg[key][name] = version;
-      added.push(name);
+      pkg[key][name] = version
+      added.push(name)
     }
   }
 
   if (added.length === 0) {
-    console.log('   Dependencies already present');
-    return;
+    console.log('   Dependencies already present')
+    return
   }
 
   // Re-write with two-space indent (Node's de-facto default; matches
   // what most generators / lint tools agree on).
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
-  console.log(`   Added to package.json: ${added.join(', ')}`);
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8')
+  console.log(`   Added to package.json: ${added.join(', ')}`)
   if (skipped.length > 0) {
-    console.log(`   Already present (kept your version): ${skipped.join(', ')}`);
+    console.log(`   Already present (kept your version): ${skipped.join(', ')}`)
   }
-  console.log('   ➜ Run `npm install` (or your package manager) before starting the dev server');
+  console.log('   ➜ Run `npm install` (or your package manager) before starting the dev server')
 }
 
 // ---------------------------------------------------------------------------
@@ -486,13 +498,13 @@ function integrateDependencies(config, targetDir) {
 // ---------------------------------------------------------------------------
 
 function printPostInstallInstructions(config) {
-  const instructions = config.instructions || [];
+  const instructions = config.instructions || []
 
   if (instructions.length > 0) {
-    console.log('\n--- Manual wiring needed ---\n');
+    console.log('\n--- Manual wiring needed ---\n')
     instructions.forEach((inst, i) => {
-      console.log(`${i + 1}. ${inst}\n`);
-    });
+      console.log(`${i + 1}. ${inst}\n`)
+    })
   }
 }
 
@@ -501,137 +513,139 @@ function printPostInstallInstructions(config) {
 // ---------------------------------------------------------------------------
 
 function main() {
-  const args = process.argv.slice(2);
+  const args = process.argv.slice(2)
 
   // --help
   if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-    console.log('\nFeature Installation Script\n');
-    console.log('Usage: node add-feature.js <feature-id> <app-dir>\n');
-    console.log('Commands:');
-    console.log('  <feature-id> <dir>  Install a feature into app dir');
-    console.log('  --list, -l          List all available features');
-    console.log('  --info <id>         Show detailed info about a feature');
-    console.log('  --help, -h          Show this help\n');
+    console.log('\nFeature Installation Script\n')
+    console.log('Usage: node add-feature.js <feature-id> <app-dir>\n')
+    console.log('Commands:')
+    console.log('  <feature-id> <dir>  Install a feature into app dir')
+    console.log('  --list, -l          List all available features')
+    console.log('  --info <id>         Show detailed info about a feature')
+    console.log('  --help, -h          Show this help\n')
 
-    const features = listFeatures();
-    const groups = groupByCategory(features);
+    const features = listFeatures()
+    const groups = groupByCategory(features)
 
     for (const category of CATEGORY_ORDER) {
-      const categoryFeatures = groups.get(category);
+      const categoryFeatures = groups.get(category)
       if (categoryFeatures && categoryFeatures.length > 0) {
-        console.log(`\n${CATEGORY_LABELS[category] || category}:`);
+        console.log(`\n${CATEGORY_LABELS[category] || category}:`)
         for (const f of categoryFeatures) {
-          console.log(`  ${f.id.padEnd(22)} ${f.name}`);
+          console.log(`  ${f.id.padEnd(22)} ${f.name}`)
         }
       }
     }
 
-    console.log('\nExamples:');
-    console.log('  add feature items-crud .');
-    console.log('  node add-feature.js items-crud ../my-app');
-    process.exit(0);
+    console.log('\nExamples:')
+    console.log('  add feature items-crud .')
+    console.log('  node add-feature.js items-crud ../my-app')
+    process.exit(0)
   }
 
   // --list
   if (args[0] === '--list' || args[0] === '-l') {
-    console.log('\nAvailable Features\n');
+    console.log('\nAvailable Features\n')
 
-    const features = listFeatures();
-    const groups = groupByCategory(features);
+    const features = listFeatures()
+    const groups = groupByCategory(features)
 
     for (const category of CATEGORY_ORDER) {
-      const categoryFeatures = groups.get(category);
+      const categoryFeatures = groups.get(category)
       if (categoryFeatures && categoryFeatures.length > 0) {
-        console.log(`${CATEGORY_LABELS[category] || category}:`);
+        console.log(`${CATEGORY_LABELS[category] || category}:`)
         for (const f of categoryFeatures) {
-          console.log(`  ${f.id.padEnd(22)} ${f.name.padEnd(24)} ${f.description}`);
+          console.log(`  ${f.id.padEnd(22)} ${f.name.padEnd(24)} ${f.description}`)
         }
-        console.log('');
+        console.log('')
       }
     }
 
-    console.log('Use: npx deepspace add <feature-id>');
-    process.exit(0);
+    console.log('Use: npx deepspace add <feature-id>')
+    process.exit(0)
   }
 
   // --info
   if (args[0] === '--info' || args[0] === '-i') {
-    const featureId = args[1];
+    const featureId = args[1]
     if (!featureId) {
-      console.error('\nError: Please specify a feature ID');
-      process.exit(1);
+      console.error('\nError: Please specify a feature ID')
+      process.exit(1)
     }
-    const config = loadFeatureConfig(featureId);
+    const config = loadFeatureConfig(featureId)
     if (!config) {
-      console.error(`\nError: Unknown feature: ${featureId}`);
-      console.error('Use --list to see available features');
-      process.exit(1);
+      console.error(`\nError: Unknown feature: ${featureId}`)
+      console.error('Use --list to see available features')
+      process.exit(1)
     }
 
-    console.log(`\n${config.name} (${config.id})`);
+    console.log(`\n${config.name} (${config.id})`)
     if (config.category) {
-      console.log(`   Category: ${CATEGORY_LABELS[config.category] || config.category}`);
+      console.log(`   Category: ${CATEGORY_LABELS[config.category] || config.category}`)
     }
-    console.log(`   ${config.description}\n`);
-    console.log(`   ${config.details}\n`);
+    console.log(`   ${config.description}\n`)
+    console.log(`   ${config.details}\n`)
 
-    console.log('   Files:');
-    config.files.forEach(f => console.log(`   - ${f.src} -> ${resolveDestPath(f.dest, config.route)}`));
+    console.log('   Files:')
+    config.files.forEach((f) =>
+      console.log(`   - ${f.src} -> ${resolveDestPath(f.dest, config.route)}`),
+    )
 
     if (config.instructions && config.instructions.length > 0) {
-      console.log('\n   Integration steps:');
-      config.instructions.forEach((inst, i) => console.log(`   ${i + 1}. ${inst}`));
+      console.log('\n   Integration steps:')
+      config.instructions.forEach((inst, i) => console.log(`   ${i + 1}. ${inst}`))
     }
 
     if (config.patterns && config.patterns.length > 0) {
-      console.log('\n   Patterns:');
-      config.patterns.forEach(p => console.log(`   - ${p}`));
+      console.log('\n   Patterns:')
+      config.patterns.forEach((p) => console.log(`   - ${p}`))
     }
 
     if (config.example) {
-      console.log('\n   Example:');
-      config.example.split('\n').forEach(line => console.log(`   ${line}`));
+      console.log('\n   Example:')
+      config.example.split('\n').forEach((line) => console.log(`   ${line}`))
     }
-    console.log('');
-    process.exit(0);
+    console.log('')
+    process.exit(0)
   }
 
   // Install feature
-  const featureId = args[0];
-  const rawDir = args[1];
-  const targetDir = resolveTargetDir(rawDir);
+  const featureId = args[0]
+  const rawDir = args[1]
+  const targetDir = resolveTargetDir(rawDir)
 
   if (!targetDir) {
-    console.error('\nError: Please specify an app directory');
-    console.error('Usage: node add-feature.js <feature-id> <app-dir>');
-    process.exit(1);
+    console.error('\nError: Please specify an app directory')
+    console.error('Usage: node add-feature.js <feature-id> <app-dir>')
+    process.exit(1)
   }
 
-  const config = loadFeatureConfig(featureId);
+  const config = loadFeatureConfig(featureId)
   if (!config) {
-    console.error(`\nError: Unknown feature: ${featureId}`);
-    console.error('Use --list to see available features');
-    process.exit(1);
+    console.error(`\nError: Unknown feature: ${featureId}`)
+    console.error('Use --list to see available features')
+    process.exit(1)
   }
 
   if (!fs.existsSync(targetDir)) {
-    console.error(`\nError: Target directory not found: ${targetDir}`);
-    process.exit(1);
+    console.error(`\nError: Target directory not found: ${targetDir}`)
+    process.exit(1)
   }
 
-  console.log(`\nInstalling: ${config.name}`);
-  console.log(`   ${config.description}`);
-  console.log(`   Target: ${targetDir}`);
+  console.log(`\nInstalling: ${config.name}`)
+  console.log(`   ${config.description}`)
+  console.log(`   Target: ${targetDir}`)
 
-  const { copied, skipped } = installFeature(config, targetDir);
+  const { copied, skipped } = installFeature(config, targetDir)
 
-  console.log(`\nCopied ${copied} file(s)${skipped > 0 ? `, skipped ${skipped} existing` : ''}`);
+  console.log(`\nCopied ${copied} file(s)${skipped > 0 ? `, skipped ${skipped} existing` : ''}`)
 
   // Auto-integrate schema, actions, CSS, and route
-  integrateSchema(config, targetDir);
-  integrateActions(config, targetDir);
-  integrateCss(config, targetDir);
-  integrateRoute(config, targetDir);
+  integrateSchema(config, targetDir)
+  integrateActions(config, targetDir)
+  integrateCss(config, targetDir)
+  integrateRoute(config, targetDir)
 
   // Add any new npm dependencies the feature declares to the target's
   // package.json. Without this, copied source files import packages
@@ -640,16 +654,16 @@ function main() {
   // package.json (rather than running `npm install` ourselves) so the
   // user keeps control over their package manager + lockfile, and we
   // print a single clear instruction when changes were made.
-  integrateDependencies(config, targetDir);
+  integrateDependencies(config, targetDir)
 
   // Print any remaining manual wiring instructions
-  printPostInstallInstructions(config);
+  printPostInstallInstructions(config)
 
   if (config.patterns && config.patterns.length > 0) {
-    console.log('--- Key patterns ---\n');
-    config.patterns.forEach(p => console.log(`- ${p}`));
-    console.log('');
+    console.log('--- Key patterns ---\n')
+    config.patterns.forEach((p) => console.log(`- ${p}`))
+    console.log('')
   }
 }
 
-main();
+main()