dappbooster 3.1.5 → 3.3.0

package/dist/operations/cleanupFiles.js

@@ -1,26 +1,156 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { copyFile, mkdir, rm } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { getStackConfig } from '../constants/config.js';
 import { isFeatureSelected } from '../utils/utils.js';
-function patchPackageJson(projectFolder, features) {
+import { execFile } from './exec.js';
+// CI config is hygiene for both stacks. EVM additionally always strips its agent/LLM metadata;
+// Canton keeps that metadata under the optional `llm` feature instead.
+const CI_PATHS = ['.github'];
+const EVM_METADATA_PATHS = ['.claude', 'AGENTS.md', 'CLAUDE.md', 'architecture.md'];
+const AUTOMATION_PATHS = ['.husky', '.lintstagedrc.mjs', 'commitlint.config.js'];
+const TOOLING_PACKAGES_TO_REMOVE = [
+    'husky',
+    'lint-staged',
+    '@commitlint/cli',
+    '@commitlint/config-conventional',
+];
+const TOOLING_SCRIPTS_TO_REMOVE = ['prepare', 'commitlint', 'commitlint:check', 'commitlint:ci'];
+function removePackageKeys(packageBlock, keys) {
+    if (!packageBlock) {
+        return false;
+    }
+    let changed = false;
+    for (const key of keys) {
+        if (key in packageBlock) {
+            delete packageBlock[key];
+            changed = true;
+        }
+    }
+    return changed;
+}
+// Strip the husky/lint-staged/commitlint tooling scripts and dependencies from a parsed
+// package.json (mutates in place). Returns whether anything was removed.
+function stripToolingEntries(packageJson, scripts) {
+    let changed = false;
+    if (scripts) {
+        for (const scriptName of TOOLING_SCRIPTS_TO_REMOVE) {
+            if (scripts[scriptName] !== undefined) {
+                scripts[scriptName] = undefined;
+                changed = true;
+            }
+        }
+    }
+    const dependencyGroups = [
+        packageJson.dependencies,
+        packageJson.devDependencies,
+        packageJson.optionalDependencies,
+        packageJson.peerDependencies,
+    ];
+    for (const group of dependencyGroups) {
+        if (removePackageKeys(group, TOOLING_PACKAGES_TO_REMOVE)) {
+            changed = true;
+        }
+    }
+    return changed;
+}
+function sanitizeRepositoryPackageJson(projectFolder) {
+    const packageJsonPath = resolve(projectFolder, 'package.json');
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        const scripts = packageJson.scripts;
+        if (stripToolingEntries(packageJson, scripts)) {
+            writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+        }
+    }
+    catch {
+        // Some templates may not include a package.json at this level.
+    }
+}
+async function removePaths(projectFolder, relativePaths) {
+    for (const relativePath of relativePaths) {
+        await rm(resolve(projectFolder, relativePath), { recursive: true, force: true });
+    }
+}
+// EVM-only hygiene: always strip CI metadata, agent metadata, and git automation. Canton models
+// .github and pre-commit hooks as optional features instead (see cleanupCantonFiles).
+async function cleanupRepositoryHygiene(projectFolder, onProgress) {
+    onProgress?.('Repository metadata');
+    await removePaths(projectFolder, [...EVM_METADATA_PATHS, ...CI_PATHS]);
+    onProgress?.('Git hooks and commit linting');
+    await removePaths(projectFolder, AUTOMATION_PATHS);
+    sanitizeRepositoryPackageJson(projectFolder);
+}
+function patchPackageJsonEvm(projectFolder, features) {
     const packageJsonPath = resolve(projectFolder, 'package.json');
     const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const scripts = packageJson.scripts;
+    if (!scripts) {
+        writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+        return;
+    }
     if (!isFeatureSelected('subgraph', features)) {
-        packageJson.scripts['subgraph-codegen'] = undefined;
+        scripts['subgraph-codegen'] = undefined;
     }
     if (!isFeatureSelected('typedoc', features)) {
-        packageJson.scripts['typedoc:build'] = undefined;
+        scripts['typedoc:build'] = undefined;
     }
     if (!isFeatureSelected('vocs', features)) {
-        packageJson.scripts['docs:build'] = undefined;
-        packageJson.scripts['docs:dev'] = undefined;
-        packageJson.scripts['docs:preview'] = undefined;
+        scripts['docs:build'] = undefined;
+        scripts['docs:dev'] = undefined;
+        scripts['docs:preview'] = undefined;
+    }
+    // biome-ignore lint/complexity/useLiteralKeys: TS index-signature compatibility in strict mode
+    scripts['prepare'] = undefined;
+    // biome-ignore lint/complexity/useLiteralKeys: TS index-signature compatibility in strict mode
+    scripts['commitlint'] = undefined;
+    scripts['commitlint:check'] = undefined;
+    scripts['commitlint:ci'] = undefined;
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+// Strip scripts by what they run (e.g. `npm --prefix carpincho-wallet ...`)
+// rather than by name, so cleanup tracks directory removal even as scripts change.
+function scriptTargetsRemovedDir(command, removedDirs) {
+    const tokens = command.split(/\s+/);
+    return removedDirs.some((dir) => tokens.some((token) => token === dir || token.startsWith(`${dir}/`)));
+}
+function patchPackageJsonCanton(projectFolder, removedDirs, precommitRemoved) {
+    const packageJsonPath = resolve(projectFolder, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const scripts = packageJson.scripts;
+    if (scripts) {
+        for (const [name, command] of Object.entries(scripts)) {
+            if (command !== undefined && scriptTargetsRemovedDir(command, removedDirs)) {
+                scripts[name] = undefined;
+            }
+        }
     }
-    if (!isFeatureSelected('husky', features)) {
-        packageJson.scripts.prepare = undefined;
+    // The husky tooling (prepare/commitlint scripts + husky/lint-staged/commitlint deps) only leaves
+    // with the pre-commit feature.
+    if (precommitRemoved) {
+        stripToolingEntries(packageJson, scripts);
     }
     writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
 }
+async function createInitialCommit(projectFolder) {
+    await execFile('git', ['add', '.'], { cwd: projectFolder });
+    // --no-verify: the scaffold's baseline commit must not run the project's own git hooks. When the
+    // `precommit` feature is kept, husky's pre-commit/commit-msg hooks are present and would lint and
+    // test the freshly-cloned tree (and fail), blocking the install. The user's later commits still
+    // run hooks normally.
+    await execFile('git', [
+        '-c',
+        'user.name=dAppBooster',
+        '-c',
+        'user.email=no-reply@dappbooster.dev',
+        '-c',
+        'commit.gpgsign=false',
+        'commit',
+        '--no-verify',
+        '-m',
+        'chore: initial commit',
+    ], { cwd: projectFolder });
+}
 async function cleanupDemo(projectFolder) {
     const homeFolder = resolve(projectFolder, 'src/components/pageComponents/home');
     await rm(homeFolder, { recursive: true, force: true });
@@ -43,12 +173,7 @@ async function cleanupVocs(projectFolder) {
     await rm(resolve(projectFolder, 'vocs.config.ts'), { force: true });
     await rm(resolve(projectFolder, 'docs'), { recursive: true, force: true });
 }
-async function cleanupHusky(projectFolder) {
-    await rm(resolve(projectFolder, '.husky'), { recursive: true, force: true });
-    await rm(resolve(projectFolder, '.lintstagedrc.mjs'), { force: true });
-    await rm(resolve(projectFolder, 'commitlint.config.js'), { force: true });
-}
-export async function cleanupFiles(projectFolder, mode, features = [], onProgress) {
+async function cleanupEvmFiles(projectFolder, mode, features, onProgress) {
     if (mode === 'custom') {
         if (!isFeatureSelected('demo', features)) {
             onProgress?.('Component demos');
@@ -66,12 +191,37 @@ export async function cleanupFiles(projectFolder, mode, features = [], onProgres
             onProgress?.('Vocs');
             await cleanupVocs(projectFolder);
         }
-        if (!isFeatureSelected('husky', features)) {
-            onProgress?.('Husky');
-            await cleanupHusky(projectFolder);
-        }
-        patchPackageJson(projectFolder, features);
+        patchPackageJsonEvm(projectFolder, features);
     }
     onProgress?.('Install script');
     await rm(resolve(projectFolder, '.install-files'), { recursive: true, force: true });
 }
+async function cleanupCantonFiles(projectFolder, mode, features, onProgress) {
+    const cantonFeatures = getStackConfig('canton').features;
+    // Each deselected feature contributes its paths to removal. `default` and `custom` remove;
+    // `full` keeps everything. Directory paths also feed script stripping, so a removed feature's
+    // package.json scripts disappear with it.
+    const removedDirs = [];
+    if (mode !== 'full') {
+        for (const [name, definition] of Object.entries(cantonFeatures)) {
+            if (isFeatureSelected(name, features) || !definition.paths || definition.paths.length === 0) {
+                continue;
+            }
+            onProgress?.(definition.label);
+            await removePaths(projectFolder, definition.paths);
+            removedDirs.push(...definition.paths);
+        }
+    }
+    const precommitRemoved = mode !== 'full' && !isFeatureSelected('precommit', features);
+    patchPackageJsonCanton(projectFolder, removedDirs, precommitRemoved);
+}
+export async function cleanupFiles(stack, projectFolder, mode, features = [], onProgress) {
+    if (stack === 'canton') {
+        await cleanupCantonFiles(projectFolder, mode, features, onProgress);
+        onProgress?.('Initial commit');
+        await createInitialCommit(projectFolder);
+        return;
+    }
+    await cleanupRepositoryHygiene(projectFolder, onProgress);
+    await cleanupEvmFiles(projectFolder, mode, features, onProgress);
+}

package/dist/operations/cloneRepo.d.ts

@@ -1 +1,2 @@
-export declare function cloneRepo(projectName: string, onProgress?: (step: string) => void): Promise<void>;
+import { type Stack } from '../constants/config.js';
+export declare function cloneRepo(stack: Stack, projectName: string, onProgress?: (step: string) => void): Promise<void>;

package/dist/operations/cloneRepo.js

@@ -1,19 +1,43 @@
 import { rm } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { repoUrl } from '../constants/config.js';
+import { getStackConfig } from '../constants/config.js';
 import { getProjectFolder } from '../utils/utils.js';
 import { exec, execFile } from './exec.js';
-export async function cloneRepo(projectName, onProgress) {
+export async function cloneRepo(stack, projectName, onProgress) {
+    const config = getStackConfig(stack);
     const projectFolder = getProjectFolder(projectName);
-    onProgress?.(`Cloning dAppBooster in ${projectName}`);
-    await execFile('git', ['clone', '--depth', '1', '--no-checkout', repoUrl, projectName]);
-    onProgress?.('Fetching tags');
-    await execFile('git', ['fetch', '--tags'], { cwd: projectFolder });
-    onProgress?.('Checking out latest tag');
-    // Shell required for $() command substitution
-    await exec('git checkout $(git describe --tags $(git rev-list --tags --max-count=1))', {
-        cwd: projectFolder,
-    });
+    if (config.refType === 'branch') {
+        const branch = config.ref;
+        if (!branch) {
+            throw new Error(`Stack '${stack}' has refType 'branch' but no 'ref' configured`);
+        }
+        onProgress?.(`Cloning ${config.label} (branch ${branch}) in ${projectName}`);
+        await execFile('git', [
+            'clone',
+            '--depth',
+            '1',
+            '--branch',
+            branch,
+            '--single-branch',
+            config.repoUrl,
+            projectName,
+        ]);
+    }
+    else {
+        onProgress?.(`Cloning ${config.label} in ${projectName}`);
+        await execFile('git', ['clone', '--depth', '1', '--no-checkout', config.repoUrl, projectName]);
+        onProgress?.('Fetching tags');
+        await execFile('git', ['fetch', '--tags'], { cwd: projectFolder });
+        onProgress?.('Checking out latest tag');
+        // Shell required for $() command substitution
+        await exec('git checkout $(git describe --tags $(git rev-list --tags --max-count=1))', {
+            cwd: projectFolder,
+        });
+    }
+    for (const dir of config.removeAfterClone) {
+        onProgress?.(`Removing ${dir}`);
+        await rm(resolve(projectFolder, dir), { recursive: true, force: true });
+    }
     onProgress?.('Removing .git folder');
     await rm(resolve(projectFolder, '.git'), { recursive: true, force: true });
     onProgress?.('Initializing Git repository');

package/dist/operations/createEnvFile.d.ts

@@ -1 +1,2 @@
-export declare function createEnvFile(projectFolder: string): Promise<void>;
+import { type FeatureName, type Stack } from '../constants/config.js';
+export declare function createEnvFile(stack: Stack, projectFolder: string, features?: FeatureName[]): Promise<void>;

package/dist/operations/createEnvFile.js

@@ -1,5 +1,12 @@
 import { copyFile } from 'node:fs/promises';
 import { join } from 'node:path';
-export async function createEnvFile(projectFolder) {
-    await copyFile(join(projectFolder, '.env.example'), join(projectFolder, '.env.local'));
+import { getStackConfig } from '../constants/config.js';
+export async function createEnvFile(stack, projectFolder, features = []) {
+    const envFiles = getStackConfig(stack).envFiles;
+    for (const file of envFiles) {
+        if (file.ifFeature !== undefined && !features.includes(file.ifFeature)) {
+            continue;
+        }
+        await copyFile(join(projectFolder, file.from), join(projectFolder, file.to));
+    }
 }

package/dist/operations/installGuard.d.ts

@@ -0,0 +1,8 @@
+type RemoveDirectory = (path: string, options: {
+    recursive: boolean;
+    force: boolean;
+}) => void;
+export declare function removeActiveProject(rm?: RemoveDirectory): void;
+export declare function beginInstall(projectFolder: string): void;
+export declare function completeInstall(): void;
+export {};

package/dist/operations/installGuard.js

@@ -0,0 +1,35 @@
+import { rmSync } from 'node:fs';
+import process from 'node:process';
+// Tracks the project folder currently being scaffolded so an interrupt can remove the partial
+// directory. Only ever holds a folder the installer created this run (callers validate that the
+// directory did not exist before starting), so removing it on abort never touches user data.
+let activeProjectFolder;
+let signalHandlersRegistered = false;
+// Removes the in-progress project folder, if any, then clears the active reference so a finished
+// or already-removed project is never deleted. `rm` is injectable for testing.
+export function removeActiveProject(rm = rmSync) {
+    if (activeProjectFolder === undefined) {
+        return;
+    }
+    const folder = activeProjectFolder;
+    activeProjectFolder = undefined;
+    rm(folder, { recursive: true, force: true });
+}
+function handleAbort(signal) {
+    removeActiveProject();
+    // Conventional exit code for a signal is 128 + signal number (SIGINT 2 → 130, SIGTERM 15 → 143).
+    process.exit(signal === 'SIGTERM' ? 143 : 130);
+}
+// Marks the start of disk-writing work. Registers interrupt handlers on first use.
+export function beginInstall(projectFolder) {
+    activeProjectFolder = projectFolder;
+    if (!signalHandlersRegistered) {
+        process.on('SIGINT', handleAbort);
+        process.on('SIGTERM', handleAbort);
+        signalHandlersRegistered = true;
+    }
+}
+// Marks the scaffold complete; an interrupt after this point leaves the finished project intact.
+export function completeInstall() {
+    activeProjectFolder = undefined;
+}

package/dist/operations/installPackages.d.ts

@@ -1,3 +1,3 @@
-import type { FeatureName } from '../constants/config.js';
+import { type FeatureName, type Stack } from '../constants/config.js';
 import type { InstallationType } from '../types/types.js';
-export declare function installPackages(projectFolder: string, mode: InstallationType, features?: FeatureName[], onProgress?: (step: string) => void): Promise<void>;
+export declare function installPackages(stack: Stack, projectFolder: string, mode: InstallationType, features?: FeatureName[], onProgress?: (step: string) => void): Promise<void>;

package/dist/operations/installPackages.js

@@ -1,19 +1,27 @@
+import { getStackConfig, } from '../constants/config.js';
 import { getPackagesToRemove } from '../utils/utils.js';
 import { execFile } from './exec.js';
-export async function installPackages(projectFolder, mode, features = [], onProgress) {
+const removeCommand = {
+    pnpm: 'remove',
+    npm: 'uninstall',
+};
+export async function installPackages(stack, projectFolder, mode, features = [], onProgress) {
+    const { packageManager } = getStackConfig(stack);
     if (mode === 'full') {
         onProgress?.('Installing packages');
-        await execFile('pnpm', ['i'], { cwd: projectFolder });
+        await execFile(packageManager, ['install'], { cwd: projectFolder });
         return;
     }
-    const packagesToRemove = getPackagesToRemove(features);
+    const packagesToRemove = getPackagesToRemove(stack, features);
     if (packagesToRemove.length === 0) {
         onProgress?.('Installing packages');
-        await execFile('pnpm', ['i'], { cwd: projectFolder });
+        await execFile(packageManager, ['install'], { cwd: projectFolder });
         return;
     }
     onProgress?.('Installing packages');
-    await execFile('pnpm', ['remove', ...packagesToRemove], { cwd: projectFolder });
+    await execFile(packageManager, [removeCommand[packageManager], ...packagesToRemove], {
+        cwd: projectFolder,
+    });
     onProgress?.('Executing post-install scripts');
-    await execFile('pnpm', ['run', 'postinstall'], { cwd: projectFolder });
+    await execFile(packageManager, ['run', 'postinstall'], { cwd: projectFolder });
 }

package/dist/types/types.d.ts

@@ -3,7 +3,7 @@ export type SelectItem = {
     value: string;
 };
 export type MultiSelectItem = SelectItem;
-export type InstallationType = 'full' | 'custom';
+export type InstallationType = 'full' | 'default' | 'custom';
 export type InstallationSelectItem = {
     label: string;
     value: InstallationType;

package/dist/utils/utils.d.ts

@@ -1,11 +1,17 @@
-import { type FeatureName } from '../constants/config.js';
+import { type FeatureName, type Stack } from '../constants/config.js';
+import type { InstallationType } from '../types/types.js';
 export declare function getProjectFolder(projectName: string): string;
 export declare function isValidName(name: string): boolean;
 export declare function isAnswerConfirmed(answer?: string, errorMessage?: string): boolean;
 export declare function canShowStep(currentStep: number, stepToShow: number): boolean;
 export declare function isFeatureSelected(feature: FeatureName, selectedFeatures: FeatureName[]): boolean;
-export declare function getPackagesToRemove(selectedFeatures: FeatureName[]): string[];
-export declare function getPostInstallMessages(mode: 'full' | 'custom', selectedFeatures: FeatureName[]): string[];
+type FeatureToggleAction = 'select' | 'unselect';
+export declare function resolveSelectedFeatures(stack: Stack, selectedFeatures: FeatureName[]): FeatureName[];
+export declare function applyFeatureToggle(stack: Stack, selectedFeatures: FeatureName[], toggledFeature: FeatureName, action: FeatureToggleAction): FeatureName[];
+export declare function describeInstallPlan(stack: Stack, projectName: string, mode: InstallationType, selectedFeatures: FeatureName[]): string;
+export declare function getPackagesToRemove(stack: Stack, selectedFeatures: FeatureName[]): string[];
+export declare function getPostInstallMessages(stack: Stack, mode: InstallationType, selectedFeatures: FeatureName[]): string[];
+export declare function resolveModeFeatures(stack: Stack, mode: InstallationType, customSelection?: FeatureName[]): FeatureName[];
 export declare function projectDirectoryExists(projectName: string): boolean;
 type StepStatus = 'running' | 'done' | 'error';
 type StepDisplay = {

package/dist/utils/utils.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import process from 'node:process';
-import { featureDefinitions } from '../constants/config.js';
+import { getDefaultFeatureNames, getFeatureNames, getStackConfig, } from '../constants/config.js';
 export function getProjectFolder(projectName) {
     return join(process.cwd(), projectName);
 }
@@ -17,16 +17,88 @@ export function canShowStep(currentStep, stepToShow) {
 export function isFeatureSelected(feature, selectedFeatures) {
     return selectedFeatures.includes(feature);
 }
-export function getPackagesToRemove(selectedFeatures) {
-    return Object.entries(featureDefinitions)
+// Walks a feature's `requires` chain, adding every (transitive) requirement to `accumulator`.
+function collectRequiredFeatures(stack, feature, accumulator) {
+    const definition = getStackConfig(stack).features[feature];
+    if (!definition?.requires) {
+        return;
+    }
+    for (const required of definition.requires) {
+        if (!accumulator.has(required)) {
+            accumulator.add(required);
+            collectRequiredFeatures(stack, required, accumulator);
+        }
+    }
+}
+// Features that depend (transitively) on `target` — removing `target` should remove these too.
+function getDependentFeatures(stack, target) {
+    const dependents = new Set();
+    for (const name of getFeatureNames(stack)) {
+        const required = new Set();
+        collectRequiredFeatures(stack, name, required);
+        if (required.has(target)) {
+            dependents.add(name);
+        }
+    }
+    return dependents;
+}
+// Expands a selection to include every transitive requirement, returned in config order.
+export function resolveSelectedFeatures(stack, selectedFeatures) {
+    const resolved = new Set(selectedFeatures);
+    for (const feature of selectedFeatures) {
+        collectRequiredFeatures(stack, feature, resolved);
+    }
+    return getFeatureNames(stack).filter((name) => resolved.has(name));
+}
+// Interactive toggle that keeps the selection dependency-consistent: selecting a feature pulls
+// its requirements in; unselecting one cascades its dependents out. Result is in config order.
+export function applyFeatureToggle(stack, selectedFeatures, toggledFeature, action) {
+    if (action === 'select') {
+        return resolveSelectedFeatures(stack, [...selectedFeatures, toggledFeature]);
+    }
+    const toRemove = getDependentFeatures(stack, toggledFeature);
+    toRemove.add(toggledFeature);
+    return getFeatureNames(stack).filter((name) => selectedFeatures.includes(name) && !toRemove.has(name));
+}
+// One-line summary of an install plan, shown on the interactive confirmation step before any disk
+// work begins.
+export function describeInstallPlan(stack, projectName, mode, selectedFeatures) {
+    const stackLabel = getStackConfig(stack).label;
+    const head = `Stack: ${stackLabel} · Project: ${projectName}`;
+    if (mode === 'full') {
+        return `${head} · Mode: full (all features)`;
+    }
+    if (mode === 'default') {
+        return `${head} · Mode: default (recommended)`;
+    }
+    const features = selectedFeatures.length > 0 ? selectedFeatures.join(', ') : 'none';
+    return `${head} · Mode: custom · Features: ${features}`;
+}
+export function getPackagesToRemove(stack, selectedFeatures) {
+    const features = getStackConfig(stack).features;
+    return Object.entries(features)
         .filter(([name]) => !selectedFeatures.includes(name))
         .flatMap(([, def]) => def.packages);
 }
-export function getPostInstallMessages(mode, selectedFeatures) {
+export function getPostInstallMessages(stack, mode, selectedFeatures) {
+    const config = getStackConfig(stack);
+    const features = config.features;
+    const stackLevel = config.postInstall ?? [];
+    const kept = resolveModeFeatures(stack, mode, selectedFeatures);
+    const featureMessages = kept.flatMap((name) => features[name]?.postInstall ?? []);
+    return [...stackLevel, ...featureMessages];
+}
+// Resolves the kept-feature list for a mode: full → all, default → default:true set,
+// custom → the user's selection (transitive requires resolved). Shared by the non-interactive
+// path and the interactive Install/FileCleanup/PostInstall steps.
+export function resolveModeFeatures(stack, mode, customSelection = []) {
     if (mode === 'full') {
-        return Object.values(featureDefinitions).flatMap((def) => def.postInstall ?? []);
+        return getFeatureNames(stack);
+    }
+    if (mode === 'default') {
+        return getDefaultFeatureNames(stack);
     }
-    return selectedFeatures.flatMap((name) => featureDefinitions[name]?.postInstall ?? []);
+    return resolveSelectedFeatures(stack, customSelection);
 }
 export function projectDirectoryExists(projectName) {
     return existsSync(getProjectFolder(projectName));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dappbooster",
-  "version": "3.1.5",
+  "version": "3.3.0",
   "description": "Agent-friendly dAppBooster installer that scaffolds Web3 dApps via TUI or non-interactive CLI/CI.",
   "keywords": [
     "dappbooster",
@@ -39,9 +39,7 @@
     "lint": "pnpm biome check",
     "lint:fix": "pnpm biome check --write"
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "dependencies": {
     "figures": "^6.1.0",
     "ink": "^5.2.1",
@@ -63,10 +61,5 @@
     "ts-node": "^10.9.1",
     "typescript": "^5.8.3",
     "vitest": "^4.1.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "@biomejs/biome"
-    ]
   }
 }