dappbooster 3.0.2 → 3.1.4

package/dist/app.js

@@ -18,13 +18,12 @@ const App = () => {
     const finishStep = useCallback(() => setCurrentStep((prevStep) => prevStep + 1), []);
     const onSelectSetupType = useCallback((item) => setSetupType(item), []);
     const onSelectSelectedFeatures = useCallback((selectedItems) => setSelectedFeatures([...selectedItems]), []);
+    const skipFeatures = setupType?.value === 'full';
     const steps = useMemo(() => [
         _jsx(ProjectName, { onCompletion: finishStep, onSubmit: setProjectName, projectName: projectName }, 1),
         _jsx(CloneRepo, { onCompletion: finishStep, projectName: projectName }, 2),
         _jsx(InstallationMode, { onCompletion: finishStep, onSelect: onSelectSetupType }, 3),
-        // TODO: add a skip parameter to all (or most) steps
-        // to allow skipping when testing, etc.
-        _jsx(OptionalPackages, { onCompletion: finishStep, onSubmit: onSelectSelectedFeatures, skip: setupType?.value === 'full' }, 4),
+        _jsx(OptionalPackages, { onCompletion: finishStep, onSubmit: onSelectSelectedFeatures, skip: skipFeatures }, 4),
         _jsx(Install, { installationConfig: {
                 installationType: setupType?.value,
                 selectedFeatures: selectedFeatures,
@@ -44,6 +43,7 @@ const App = () => {
         selectedFeatures,
         onSelectSetupType,
         projectName,
+        skipFeatures,
     ]);
     return (_jsxs(Box, { flexDirection: 'column', rowGap: 1, width: 80, children: [_jsx(MainTitle, {}), steps.map((item, index) => canShowStep(currentStep, index + 1) && item)] }));
 };

package/dist/cli.js

@@ -1,6 +1,97 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from 'ink';
-import App from './app.js';
-console.clear();
-render(_jsx(App, {}));
+import process from 'node:process';
+import meow from 'meow';
+import { getInfoOutput } from './info.js';
+import { runNonInteractive } from './nonInteractive.js';
+const cli = meow(`
+  Usage
+    $ dappbooster [options]
+
+  Options
+    --name <string>          Project name (alphanumeric, underscores)
+    --mode <full|custom>     Installation mode
+    --features <list>        Comma-separated features (with --mode=custom):
+                               demo       Component demos and example pages
+                               subgraph   TheGraph subgraph integration (requires API key)
+                               typedoc    TypeDoc API documentation generation
+                               vocs       Vocs documentation site
+                               husky      Git hooks with Husky, lint-staged, commitlint
+    --non-interactive, --ni  Run without prompts (auto-enabled when not a TTY)
+    --info                   Output feature metadata as JSON
+    --help                   Show this help
+    --version                Show version
+
+  Non-interactive mode
+    Requires --name and --mode. Outputs JSON to stdout.
+    Activates automatically when stdout is not a TTY.
+    Use --ni to force non-interactive mode in a TTY environment.
+
+    AI agents: non-interactive mode activates automatically. Run --info
+    to discover available features, then pass --name and --mode flags.
+    Output is JSON for easy parsing.
+
+  Examples
+    Interactive:
+      $ dappbooster
+
+    Full install (non-interactive):
+      $ dappbooster --ni --name my_dapp --mode full
+
+    Custom install with specific features:
+      $ dappbooster --ni --name my_dapp --mode custom --features demo,subgraph
+
+    Get feature metadata:
+      $ dappbooster --info
+`, {
+    importMeta: import.meta,
+    flags: {
+        name: {
+            type: 'string',
+        },
+        mode: {
+            type: 'string',
+        },
+        features: {
+            type: 'string',
+        },
+        nonInteractive: {
+            type: 'boolean',
+            default: false,
+        },
+        ni: {
+            type: 'boolean',
+            default: false,
+        },
+        info: {
+            type: 'boolean',
+            default: false,
+        },
+    },
+});
+if (cli.flags.info) {
+    console.log(getInfoOutput());
+}
+else if (cli.flags.nonInteractive || cli.flags.ni || !process.stdout.isTTY) {
+    runNonInteractive({
+        name: cli.flags.name,
+        mode: cli.flags.mode,
+        features: cli.flags.features,
+    }).catch((error) => {
+        if (process.exitCode === 1) {
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(JSON.stringify({ success: false, error: message }, null, 2));
+        process.exitCode = 1;
+    });
+}
+else {
+    const run = async () => {
+        console.clear();
+        const { render } = await import('ink');
+        const { default: App } = await import('./app.js');
+        render(_jsx(App, {}));
+    };
+    run().catch(console.error);
+}

package/dist/components/steps/CloneRepo/CloneRepo.d.ts

@@ -1,13 +1,7 @@
-import type { FC } from 'react';
+import { type FC } from 'react';
 interface Props {
     projectName: string;
     onCompletion: () => void;
 }
-/**
- * Step for cloning the repository.
- * @param projectName
- * @param onCompletion
- * @constructor
- */
 declare const CloneRepo: FC<Props>;
 export default CloneRepo;

package/dist/components/steps/CloneRepo/CloneRepo.js

@@ -1,11 +1,28 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { useCallback, useEffect, useState } from 'react';
+import { cloneRepo } from '../../../operations/index.js';
+import { deriveStepDisplay } from '../../../utils/utils.js';
 import Divider from '../../Divider.js';
-import Commands from './Commands.js';
-/**
- * Step for cloning the repository.
- * @param projectName
- * @param onCompletion
- * @constructor
- */
-const CloneRepo = ({ projectName, onCompletion }) => (_jsxs(_Fragment, { children: [_jsx(Divider, { title: 'Git tasks' }), _jsx(Commands, { projectName: projectName, onCompletion: onCompletion })] }));
+const CloneRepo = ({ projectName, onCompletion }) => {
+    const [steps, setSteps] = useState([]);
+    const [status, setStatus] = useState('running');
+    const [errorMessage, setErrorMessage] = useState('');
+    const handleProgress = useCallback((step) => {
+        setSteps((prev) => [...prev, step]);
+    }, []);
+    useEffect(() => {
+        cloneRepo(projectName, handleProgress)
+            .then(() => {
+            setStatus('done');
+            onCompletion();
+        })
+            .catch((error) => {
+            setStatus('error');
+            setErrorMessage(error instanceof Error ? error.message : String(error));
+        });
+    }, [projectName, onCompletion, handleProgress]);
+    const { completedSteps, currentStep, failedStep } = deriveStepDisplay(steps, status);
+    return (_jsxs(_Fragment, { children: [_jsx(Divider, { title: 'Git tasks' }), completedSteps.map((step) => (_jsxs(Text, { children: [_jsx(Text, { color: 'green', children: '\u2714' }), " ", step] }, step))), currentStep && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: '\u25CB' }), " ", currentStep, " ", _jsx(Text, { dimColor: true, children: "Working..." })] })), failedStep && (_jsxs(Text, { children: [_jsx(Text, { color: 'red', children: '\u2717' }), " ", failedStep, " ", _jsx(Text, { color: 'red', children: "Error" })] })), status === 'error' && _jsxs(Text, { color: 'red', children: ["Failed to clone: ", errorMessage] })] }));
+};
 export default CloneRepo;

package/dist/components/steps/FileCleanup.d.ts

@@ -8,11 +8,5 @@ interface Props {
         selectedFeatures?: Array<MultiSelectItem>;
     };
 }
-/**
- * Performs file cleanup after the installation process
- * @param onCompletion
- * @param installation
- * @param projectName
- */
 declare const FileCleanup: FC<Props>;
 export default FileCleanup;

package/dist/components/steps/FileCleanup.js

@@ -1,43 +1,31 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { Box, Text } from 'ink';
-import { Script, Spawn } from 'ink-spawn';
-import { useMemo } from 'react';
-import { featureSelected, getProjectFolder } from '../../utils/utils.js';
+import { Text } from 'ink';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { cleanupFiles } from '../../operations/index.js';
+import { deriveStepDisplay, getProjectFolder } from '../../utils/utils.js';
 import Divider from '../Divider.js';
-const packageJSONCleanup = (projectFolder, selectedFeatures) => {
-    const packageJSONPath = join(projectFolder, 'package.json');
-    const packageJSON = JSON.parse(readFileSync(packageJSONPath, 'utf8'));
-    if (!featureSelected('subgraph', selectedFeatures)) {
-        packageJSON.scripts['subgraph-codegen'] = undefined;
-    }
-    if (!featureSelected('typedoc', selectedFeatures)) {
-        packageJSON.scripts['typedoc:build'] = undefined;
-    }
-    if (!featureSelected('vocs', selectedFeatures)) {
-        packageJSON.scripts['docs:build'] = undefined;
-        packageJSON.scripts['docs:dev'] = undefined;
-        packageJSON.scripts['docs:preview'] = undefined;
-    }
-    if (!featureSelected('husky', selectedFeatures)) {
-        packageJSON.scripts.prepare = undefined;
-    }
-    writeFileSync(packageJSONPath, `${JSON.stringify(packageJSON, null, 2)}\n`);
-};
-/**
- * Performs file cleanup after the installation process
- * @param onCompletion
- * @param installation
- * @param projectName
- */
 const FileCleanup = ({ onCompletion, installationConfig, projectName }) => {
     const { installationType, selectedFeatures } = installationConfig;
     const projectFolder = useMemo(() => getProjectFolder(projectName), [projectName]);
-    const currentHomeFolder = `${projectFolder}/src/components/pageComponents/home`;
-    return (_jsxs(_Fragment, { children: [_jsx(Divider, { title: 'File cleanup' }), _jsx(Box, { flexDirection: 'column', gap: 0, children: _jsxs(Script, { children: [installationType === 'custom' && (_jsxs(Script, { onCompletion: () => packageJSONCleanup(projectFolder, selectedFeatures), children: [!featureSelected('demo', selectedFeatures) && (_jsxs(Script, { children: [_jsx(Text, { color: 'whiteBright', children: "Component demos" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', currentHomeFolder], runningText: 'Removing home files...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "mkdir", args: ['-p', currentHomeFolder], runningText: 'Creating home folder...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "cp", args: ['./.install-files/home/index.tsx', currentHomeFolder], runningText: 'Creating new home page index file...', successText: 'Done!', failureText: 'Error...' })] })), !featureSelected('subgraph', selectedFeatures) && (_jsxs(Script, { children: [_jsx(Text, { color: 'whiteBright', children: "Subgraph" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './src/subgraphs'], runningText: 'Removing subgraphs folder...', successText: 'Done!', failureText: 'Error...' }), featureSelected('demo', selectedFeatures) && (_jsxs(Script, { children: [_jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', `${currentHomeFolder}/Examples/demos/subgraphs`], runningText: 'Removing subgraphs demos folder...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: [`${currentHomeFolder}/Examples/index.tsx`], runningText: 'Removing examples index file...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "cp", args: [
-                                                        './.install-files/home/Examples/index.tsx',
-                                                        `${currentHomeFolder}/Examples/index.tsx`,
-                                                    ], runningText: 'Creating new examples index file...', successText: 'Done!', failureText: 'Error...' })] }))] })), !featureSelected('typedoc', selectedFeatures) && (_jsxs(Script, { children: [_jsx(Text, { color: 'whiteBright', children: "Typedoc" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./typedoc.json'], runningText: 'Removing config...', successText: 'Done!', failureText: 'Error...' })] })), !featureSelected('vocs', selectedFeatures) && (_jsxs(Script, { children: [_jsx(Text, { color: 'whiteBright', children: "Vocs" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./vocs.config.ts'], runningText: 'Removing config...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './docs'], runningText: 'Removing docs folder...', successText: 'Done!', failureText: 'Error...' })] })), !featureSelected('husky', selectedFeatures) && (_jsxs(Script, { children: [_jsx(Text, { color: 'whiteBright', children: "Husky" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './.husky'], runningText: 'Removing Husky folder...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./.lintstagedrc.mjs'], runningText: 'Removing lint-staged config...', successText: 'Done!', failureText: 'Error...' }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./commitlint.config.js'], runningText: 'Removing commitlint config...', successText: 'Done!', failureText: 'Error...' })] }))] })), _jsx(Text, { color: 'whiteBright', children: "Install script" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './.install-files'], runningText: 'Removing folder...', successText: 'Done!', failureText: 'Error...', onCompletion: onCompletion })] }) })] }));
+    const [steps, setSteps] = useState([]);
+    const [status, setStatus] = useState('running');
+    const [errorMessage, setErrorMessage] = useState('');
+    const handleProgress = useCallback((step) => {
+        setSteps((prev) => [...prev, step]);
+    }, []);
+    useEffect(() => {
+        const features = selectedFeatures?.map((f) => f.value) ?? [];
+        cleanupFiles(projectFolder, installationType ?? 'full', features, handleProgress)
+            .then(() => {
+            setStatus('done');
+            onCompletion();
+        })
+            .catch((error) => {
+            setStatus('error');
+            setErrorMessage(error instanceof Error ? error.message : String(error));
+        });
+    }, [projectFolder, installationType, selectedFeatures, onCompletion, handleProgress]);
+    const { completedSteps, currentStep, failedStep } = deriveStepDisplay(steps, status);
+    return (_jsxs(_Fragment, { children: [_jsx(Divider, { title: 'File cleanup' }), completedSteps.map((step) => (_jsxs(Text, { children: [_jsx(Text, { color: 'green', children: '\u2714' }), " ", step] }, step))), currentStep && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: '\u25CB' }), " ", currentStep, " ", _jsx(Text, { dimColor: true, children: "Working..." })] })), failedStep && (_jsxs(Text, { children: [_jsx(Text, { color: 'red', children: '\u2717' }), " ", failedStep, " ", _jsx(Text, { color: 'red', children: "Error" })] })), status === 'error' && _jsxs(Text, { color: 'red', children: ["Cleanup failed: ", errorMessage] })] }));
 };
 export default FileCleanup;

package/dist/components/steps/Install/Install.js

@@ -1,17 +1,40 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { Script, Spawn } from 'ink-spawn';
-import { useMemo } from 'react';
-import { getProjectFolder } from '../../../utils/utils.js';
+import { Text } from 'ink';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { createEnvFile } from '../../../operations/createEnvFile.js';
+import { installPackages } from '../../../operations/installPackages.js';
+import { deriveStepDisplay, getProjectFolder } from '../../../utils/utils.js';
 import Divider from '../../Divider.js';
-import CustomInstallation from './CustomInstallation.js';
-import FullInstallation from './FullInstallation.js';
 const Install = ({ projectName, onCompletion, installationConfig }) => {
     const { installationType, selectedFeatures } = installationConfig;
     const projectFolder = useMemo(() => getProjectFolder(projectName), [projectName]);
+    const [steps, setSteps] = useState([]);
+    const [status, setStatus] = useState('running');
+    const [errorMessage, setErrorMessage] = useState('');
     const title = installationType
         ? installationType[0]?.toUpperCase() + installationType.slice(1)
-        : '';
-    return (_jsxs(_Fragment, { children: [_jsx(Divider, { title: `${title ?? 'Full'} installation` }), _jsx(Box, { flexDirection: 'column', gap: 0, children: _jsxs(Script, { children: [_jsx(Box, { columnGap: 1, children: _jsxs(Text, { color: 'whiteBright', children: ["Creating", ' ', _jsx(Text, { italic: true, color: 'white', children: ".env.local" }), ' ', "file"] }) }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'cp', args: ['.env.example', '.env.local'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...' }), installationType === 'full' && (_jsx(FullInstallation, { onCompletion: onCompletion, projectFolder: projectFolder })), installationType === 'custom' && (_jsx(CustomInstallation, { selectedFeatures: selectedFeatures, onCompletion: onCompletion, projectFolder: projectFolder }))] }) })] }));
+        : 'Full';
+    const handleProgress = useCallback((step) => {
+        setSteps((prev) => [...prev, step]);
+    }, []);
+    useEffect(() => {
+        const features = selectedFeatures?.map((f) => f.value) ?? [];
+        const run = async () => {
+            handleProgress('Creating .env.local file');
+            await createEnvFile(projectFolder);
+            await installPackages(projectFolder, installationType ?? 'full', features, handleProgress);
+        };
+        run()
+            .then(() => {
+            setStatus('done');
+            onCompletion();
+        })
+            .catch((error) => {
+            setStatus('error');
+            setErrorMessage(error instanceof Error ? error.message : String(error));
+        });
+    }, [projectFolder, installationType, selectedFeatures, onCompletion, handleProgress]);
+    const { completedSteps, currentStep, failedStep } = deriveStepDisplay(steps, status);
+    return (_jsxs(_Fragment, { children: [_jsx(Divider, { title: `${title} installation` }), completedSteps.map((step) => (_jsxs(Text, { children: [_jsx(Text, { color: 'green', children: '\u2714' }), " ", step] }, step))), currentStep && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: '\u25CB' }), " ", currentStep, " ", _jsx(Text, { dimColor: true, children: "Working..." })] })), failedStep && (_jsxs(Text, { children: [_jsx(Text, { color: 'red', children: '\u2717' }), " ", failedStep, " ", _jsx(Text, { color: 'red', children: "Error" })] })), status === 'error' && _jsxs(Text, { color: 'red', children: ["Installation failed: ", errorMessage] })] }));
 };
 export default Install;

package/dist/components/steps/OptionalPackages.d.ts

@@ -5,12 +5,5 @@ interface Props {
     onSubmit: (selectedItems: Array<MultiSelectItem>) => void;
     skip?: boolean;
 }
-/**
- * Step for selecting optional packages. Skipped if installation type is 'full'.
- * @param onCompletion
- * @param onSubmit
- * @param installation
- * @param skip
- */
 declare const OptionalPackages: FC<Props>;
 export default OptionalPackages;

package/dist/components/steps/OptionalPackages.js

@@ -1,41 +1,16 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
 import { useEffect, useState } from 'react';
+import { featureDefinitions, featureNames } from '../../constants/config.js';
 import MultiSelect from '../Multiselect/index.js';
-const customPackages = [
-    {
-        label: 'Component Demos',
-        value: 'demo',
-    },
-    {
-        label: 'Subgraph support',
-        value: 'subgraph',
-    },
-    {
-        label: 'Typedoc documentation support',
-        value: 'typedoc',
-    },
-    {
-        label: 'Vocs documentation support',
-        value: 'vocs',
-    },
-    {
-        label: 'Husky Git hooks support',
-        value: 'husky',
-    },
-];
-/**
- * Step for selecting optional packages. Skipped if installation type is 'full'.
- * @param onCompletion
- * @param onSubmit
- * @param installation
- * @param skip
- */
+const customPackages = featureNames.map((name) => ({
+    label: featureDefinitions[name].label,
+    value: name,
+}));
 const OptionalPackages = ({ onCompletion, onSubmit, skip = false }) => {
     const [isFocused, setIsFocused] = useState(true);
     // biome-ignore lint/correctness/useExhaustiveDependencies: Run this only once, no matter what
     useEffect(() => {
-        // full installation, do nothing
         if (skip) {
             onCompletion();
         }

package/dist/components/steps/PostInstall.d.ts

@@ -7,10 +7,5 @@ interface Props {
     };
     projectName: string;
 }
-/**
- * Component to ask for the project name.
- * @param selectedFeatures
- * @param projectName
- */
 declare const PostInstall: FC<Props>;
 export default PostInstall;

package/dist/components/steps/PostInstall.js

@@ -2,18 +2,14 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import figures from 'figures';
 import { Box, Text } from 'ink';
 import Link from 'ink-link';
-import { featureSelected } from '../../utils/utils.js';
+import { isFeatureSelected } from '../../utils/utils.js';
 import Divider from '../Divider.js';
 const SubgraphWarningMessage = () => (_jsxs(Box, { flexDirection: 'column', rowGap: 1, children: [_jsx(Box, { alignItems: 'center', borderColor: 'yellow', borderStyle: 'bold', flexDirection: 'column', justifyContent: 'center', padding: 1, children: _jsxs(Text, { color: 'yellow', children: [figures.warning, figures.warning, " ", _jsx(Text, { bold: true, children: "WARNING:" }), " You ", _jsx(Text, { bold: true, children: "MUST" }), " finish the subgraph's configuration manually ", figures.warning, figures.warning] }) }), _jsx(Text, { color: 'whiteBright', children: "Follow these steps:" }), _jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["1- Provide your own API key for ", _jsx(Text, { color: 'gray', children: "PUBLIC_SUBGRAPHS_API_KEY" }), " in", ' ', _jsx(Text, { color: 'gray', children: ".env.local" }), " You can get one", ' ', _jsx(Link, { url: "https://thegraph.com/studio/apikeys", children: "here" })] }), _jsxs(Text, { children: ["2- After the API key is correctly configured, run", ' ', _jsx(Text, { color: 'gray', children: "pnpm subgraph-codegen" }), " in your console from the project's folder"] })] }), _jsxs(Text, { children: ["More configuration info in", ' ', _jsx(Link, { url: 'https://docs.dappbooster.dev/introduction/getting-started', children: "the docs" }), "."] }), _jsxs(Text, { color: 'yellow', bold: true, children: [figures.info, " Only after you have followed the previous steps you may proceed."] })] }));
 const PostInstallMessage = ({ projectName }) => (_jsxs(Box, { flexDirection: 'column', rowGap: 1, paddingBottom: 2, children: [_jsx(Text, { color: 'whiteBright', children: "To start development on your project:" }), _jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["1- Move into the project's folder with ", _jsxs(Text, { color: 'gray', children: ["cd ", projectName] })] }), _jsxs(Text, { children: ["2- Start the development server with ", _jsx(Text, { color: 'gray', children: "pnpm dev" })] })] }), _jsx(Text, { color: 'whiteBright', children: "More info:" }), _jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["- Check out ", _jsx(Text, { color: 'gray', children: ".env.local" }), " for more configurations."] }), _jsxs(Text, { children: ["- Read ", _jsx(Link, { url: "https://docs.dappbooster.dev", children: "the docs" }), " to know more about", ' ', _jsx(Text, { color: 'gray', children: "dAppBooster" }), "!"] }), _jsxs(Text, { children: ["- Report issues with this installer", ' ', _jsx(Link, { url: "https://github.com/BootNodeDev/dAppBoosterInstallScript/issues", children: "here" })] })] })] }));
-/**
- * Component to ask for the project name.
- * @param selectedFeatures
- * @param projectName
- */
 const PostInstall = ({ installationConfig, projectName }) => {
     const { selectedFeatures, installationType } = installationConfig;
-    const subgraphSupport = featureSelected('subgraph', selectedFeatures);
+    const features = selectedFeatures?.map((f) => f.value) ?? [];
+    const subgraphSupport = isFeatureSelected('subgraph', features);
     return (_jsxs(_Fragment, { children: [_jsx(Divider, { title: 'Post-install instructions' }), _jsxs(Box, { flexDirection: 'column', rowGap: 2, children: [(subgraphSupport || installationType === 'full') && _jsx(SubgraphWarningMessage, {}), _jsx(PostInstallMessage, { projectName: projectName })] })] }));
 };
 export default PostInstall;

package/dist/constants/config.d.ts

@@ -1,4 +1,11 @@
 export declare const repoUrl = "https://github.com/BootNodeDev/dAppBooster.git";
-export declare const featurePackages: {
-    [key: string]: string[];
+export type FeatureName = 'demo' | 'subgraph' | 'typedoc' | 'vocs' | 'husky';
+export type FeatureDefinition = {
+    description: string;
+    label: string;
+    packages: string[];
+    default: boolean;
+    postInstall?: string[];
 };
+export declare const featureDefinitions: Record<FeatureName, FeatureDefinition>;
+export declare const featureNames: FeatureName[];

package/dist/constants/config.js

@@ -1,18 +1,50 @@
 export const repoUrl = 'https://github.com/BootNodeDev/dAppBooster.git';
-export const featurePackages = {
-    subgraph: [
-        '@bootnodedev/db-subgraph',
-        'graphql graphql-request',
-        '@graphql-codegen/cli',
-        '@graphql-typed-document-node/core',
-    ],
-    typedoc: [
-        'typedoc',
-        'typedoc-github-theme',
-        'typedoc-plugin-inline-sources',
-        'typedoc-plugin-missing-exports',
-        'typedoc-plugin-rename-defaults',
-    ],
-    vocs: ['vocs'],
-    husky: ['husky', 'lint-staged', '@commitlint/cli', '@commitlint/config-conventional'],
+export const featureDefinitions = {
+    demo: {
+        description: 'Component demos and example pages',
+        label: 'Component Demos',
+        packages: [],
+        default: true,
+    },
+    subgraph: {
+        description: 'TheGraph subgraph integration',
+        label: 'Subgraph support',
+        packages: [
+            '@bootnodedev/db-subgraph',
+            'graphql',
+            'graphql-request',
+            '@graphql-codegen/cli',
+            '@graphql-typed-document-node/core',
+        ],
+        default: true,
+        postInstall: [
+            'Provide your own API key for PUBLIC_SUBGRAPHS_API_KEY in .env.local',
+            'Run pnpm subgraph-codegen from the project folder',
+        ],
+    },
+    typedoc: {
+        description: 'TypeDoc API documentation generation',
+        label: 'Typedoc documentation support',
+        packages: [
+            'typedoc',
+            'typedoc-github-theme',
+            'typedoc-plugin-inline-sources',
+            'typedoc-plugin-missing-exports',
+            'typedoc-plugin-rename-defaults',
+        ],
+        default: true,
+    },
+    vocs: {
+        description: 'Vocs documentation site',
+        label: 'Vocs documentation support',
+        packages: ['vocs'],
+        default: true,
+    },
+    husky: {
+        description: 'Git hooks with Husky, lint-staged, and commitlint',
+        label: 'Husky Git hooks support',
+        packages: ['husky', 'lint-staged', '@commitlint/cli', '@commitlint/config-conventional'],
+        default: true,
+    },
 };
+export const featureNames = Object.keys(featureDefinitions);

package/dist/info.d.ts

@@ -0,0 +1 @@
+export declare function getInfoOutput(): string;

package/dist/info.js

@@ -0,0 +1,18 @@
+import { featureDefinitions } from './constants/config.js';
+export function getInfoOutput() {
+    const features = Object.fromEntries(Object.entries(featureDefinitions).map(([name, def]) => [
+        name,
+        {
+            description: def.description,
+            default: def.default,
+            ...(def.postInstall ? { postInstall: def.postInstall } : {}),
+        },
+    ]));
+    return JSON.stringify({
+        features,
+        modes: {
+            full: 'Install all features',
+            custom: 'Choose features individually',
+        },
+    }, null, 2);
+}

package/dist/nonInteractive.d.ts

@@ -0,0 +1,5 @@
+export declare function runNonInteractive(flags: {
+    name?: string;
+    mode?: string;
+    features?: string;
+}): Promise<void>;

package/dist/nonInteractive.js

@@ -0,0 +1,85 @@
+import process from 'node:process';
+import { featureNames } from './constants/config.js';
+import { cleanupFiles, cloneRepo, createEnvFile, installPackages } from './operations/index.js';
+import { getPostInstallMessages, getProjectFolder, isValidName, projectDirectoryExists, } from './utils/utils.js';
+function fail(error) {
+    const result = { success: false, error };
+    console.log(JSON.stringify(result, null, 2));
+    process.exitCode = 1;
+    throw new Error(error);
+}
+function parseFeatures(featuresFlag) {
+    if (!featuresFlag) {
+        return [];
+    }
+    const seen = new Set();
+    return featuresFlag
+        .split(',')
+        .map((f) => f.trim())
+        .filter((f) => {
+        if (f === '' || seen.has(f)) {
+            return false;
+        }
+        seen.add(f);
+        return true;
+    });
+}
+function validate(flags) {
+    if (!flags.name) {
+        fail('Missing required flag: --name');
+    }
+    if (!flags.mode) {
+        fail('Missing required flag: --mode');
+    }
+    if (!isValidName(flags.name)) {
+        fail('Invalid project name: only letters, numbers, and underscores are allowed');
+    }
+    if (flags.mode !== 'full' && flags.mode !== 'custom') {
+        fail("Invalid mode: must be 'full' or 'custom'");
+    }
+    // --mode=full ignores --features (everything is installed)
+    if (flags.mode === 'full') {
+        if (projectDirectoryExists(flags.name)) {
+            fail(`Project directory '${flags.name}' already exists`);
+        }
+        return { name: flags.name, mode: flags.mode, features: featureNames };
+    }
+    if (!flags.features) {
+        fail('--mode custom requires --features. Use --info to see available features.');
+    }
+    const features = parseFeatures(flags.features);
+    if (features.length === 0) {
+        fail('--features value is empty. Use --info to see available features.');
+    }
+    const invalidFeatures = features.filter((f) => !featureNames.includes(f));
+    if (invalidFeatures.length > 0) {
+        fail(`Unknown features: ${invalidFeatures.join(', ')}. Valid features: ${featureNames.join(', ')}`);
+    }
+    if (projectDirectoryExists(flags.name)) {
+        fail(`Project directory '${flags.name}' already exists`);
+    }
+    return { name: flags.name, mode: flags.mode, features };
+}
+export async function runNonInteractive(flags) {
+    const { name, mode, features } = validate(flags);
+    try {
+        await cloneRepo(name);
+        const projectFolder = getProjectFolder(name);
+        await createEnvFile(projectFolder);
+        await installPackages(projectFolder, mode, features);
+        await cleanupFiles(projectFolder, mode, features);
+        const result = {
+            success: true,
+            projectName: name,
+            mode,
+            features,
+            path: projectFolder,
+            postInstall: getPostInstallMessages(mode, features),
+        };
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        fail(message);
+    }
+}

package/dist/operations/cleanupFiles.d.ts

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

package/dist/operations/cleanupFiles.js

@@ -0,0 +1,77 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { copyFile, mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { isFeatureSelected } from '../utils/utils.js';
+function patchPackageJson(projectFolder, features) {
+    const packageJsonPath = resolve(projectFolder, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    if (!isFeatureSelected('subgraph', features)) {
+        packageJson.scripts['subgraph-codegen'] = undefined;
+    }
+    if (!isFeatureSelected('typedoc', features)) {
+        packageJson.scripts['typedoc:build'] = undefined;
+    }
+    if (!isFeatureSelected('vocs', features)) {
+        packageJson.scripts['docs:build'] = undefined;
+        packageJson.scripts['docs:dev'] = undefined;
+        packageJson.scripts['docs:preview'] = undefined;
+    }
+    if (!isFeatureSelected('husky', features)) {
+        packageJson.scripts.prepare = undefined;
+    }
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+async function cleanupDemo(projectFolder) {
+    const homeFolder = resolve(projectFolder, 'src/components/pageComponents/home');
+    await rm(homeFolder, { recursive: true, force: true });
+    await mkdir(homeFolder, { recursive: true });
+    await copyFile(resolve(projectFolder, '.install-files/home/index.tsx'), resolve(homeFolder, 'index.tsx'));
+}
+async function cleanupSubgraph(projectFolder, features) {
+    await rm(resolve(projectFolder, 'src/subgraphs'), { recursive: true, force: true });
+    if (isFeatureSelected('demo', features)) {
+        const homeFolder = resolve(projectFolder, 'src/components/pageComponents/home');
+        await rm(resolve(homeFolder, 'Examples/demos/subgraphs'), { recursive: true, force: true });
+        await rm(resolve(homeFolder, 'Examples/index.tsx'), { force: true });
+        await copyFile(resolve(projectFolder, '.install-files/home/Examples/index.tsx'), resolve(homeFolder, 'Examples/index.tsx'));
+    }
+}
+async function cleanupTypedoc(projectFolder) {
+    await rm(resolve(projectFolder, 'typedoc.json'), { force: true });
+}
+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) {
+    if (mode === 'custom') {
+        if (!isFeatureSelected('demo', features)) {
+            onProgress?.('Component demos');
+            await cleanupDemo(projectFolder);
+        }
+        if (!isFeatureSelected('subgraph', features)) {
+            onProgress?.('Subgraph');
+            await cleanupSubgraph(projectFolder, features);
+        }
+        if (!isFeatureSelected('typedoc', features)) {
+            onProgress?.('Typedoc');
+            await cleanupTypedoc(projectFolder);
+        }
+        if (!isFeatureSelected('vocs', features)) {
+            onProgress?.('Vocs');
+            await cleanupVocs(projectFolder);
+        }
+        if (!isFeatureSelected('husky', features)) {
+            onProgress?.('Husky');
+            await cleanupHusky(projectFolder);
+        }
+        patchPackageJson(projectFolder, features);
+    }
+    onProgress?.('Install script');
+    await rm(resolve(projectFolder, '.install-files'), { recursive: true, force: true });
+}

package/dist/operations/cloneRepo.d.ts

@@ -0,0 +1 @@
+export declare function cloneRepo(projectName: string, onProgress?: (step: string) => void): Promise<void>;

package/dist/operations/cloneRepo.js

@@ -0,0 +1,21 @@
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { repoUrl } from '../constants/config.js';
+import { getProjectFolder } from '../utils/utils.js';
+import { exec, execFile } from './exec.js';
+export async function cloneRepo(projectName, onProgress) {
+    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,
+    });
+    onProgress?.('Removing .git folder');
+    await rm(resolve(projectFolder, '.git'), { recursive: true, force: true });
+    onProgress?.('Initializing Git repository');
+    await execFile('git', ['init'], { cwd: projectFolder });
+}

package/dist/operations/createEnvFile.d.ts

@@ -0,0 +1 @@
+export declare function createEnvFile(projectFolder: string): Promise<void>;

package/dist/operations/createEnvFile.js

@@ -0,0 +1,5 @@
+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'));
+}

package/dist/operations/exec.d.ts

@@ -0,0 +1,6 @@
+export declare function exec(command: string, options?: {
+    cwd?: string;
+}): Promise<void>;
+export declare function execFile(file: string, args: string[], options?: {
+    cwd?: string;
+}): Promise<void>;

package/dist/operations/exec.js

@@ -0,0 +1,32 @@
+import { spawn } from 'node:child_process';
+function run(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            ...options,
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const fallback = signal !== null
+                    ? `Process killed by signal ${signal}`
+                    : `Command failed with exit code ${code}`;
+                const message = stderr.trim() || fallback;
+                reject(new Error(message));
+            }
+        });
+        child.on('error', reject);
+    });
+}
+export async function exec(command, options = {}) {
+    await run('/bin/sh', ['-c', command], { cwd: options.cwd });
+}
+export async function execFile(file, args, options = {}) {
+    await run(file, args, { cwd: options.cwd });
+}

package/dist/operations/index.d.ts

@@ -0,0 +1,4 @@
+export { cloneRepo } from './cloneRepo.js';
+export { createEnvFile } from './createEnvFile.js';
+export { installPackages } from './installPackages.js';
+export { cleanupFiles } from './cleanupFiles.js';

package/dist/operations/index.js

@@ -0,0 +1,4 @@
+export { cloneRepo } from './cloneRepo.js';
+export { createEnvFile } from './createEnvFile.js';
+export { installPackages } from './installPackages.js';
+export { cleanupFiles } from './cleanupFiles.js';

package/dist/operations/installPackages.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureName } 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>;

package/dist/operations/installPackages.js

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

package/dist/utils/utils.d.ts

@@ -1,32 +1,17 @@
-import type { MultiSelectItem } from '../types/types.js';
+import { type FeatureName } from '../constants/config.js';
 export declare function getProjectFolder(projectName: string): string;
-/**
- * Utility functions for import process
- * @param name
- */
 export declare function isValidName(name: string): boolean;
-/**
- * Checks if the answer is confirmed
- * @param answer
- * @param errorMessage
- */
 export declare function isAnswerConfirmed(answer?: string, errorMessage?: string): boolean;
-/**
- * Checks if the step can be shown
- * @param currentStep
- * @param stepToShow
- */
 export declare function canShowStep(currentStep: number, stepToShow: number): boolean;
-/**
- * Returns true a feature is selected in the features list
- * @param feature
- * @param featuresList
- */
-export declare function featureSelected(feature: string, featuresList: Array<MultiSelectItem> | undefined): boolean;
-/**
- * Returns the packages to remove checking first if the feature is selected or not.
- * Selected features are kept, unselected features are removed.
- * @param feature
- * @param featuresList
- */
-export declare function getPackages(feature: string, featuresList: Array<MultiSelectItem> | undefined): string[];
+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[];
+export declare function projectDirectoryExists(projectName: string): boolean;
+type StepStatus = 'running' | 'done' | 'error';
+type StepDisplay = {
+    completedSteps: string[];
+    currentStep: string | undefined;
+    failedStep: string | undefined;
+};
+export declare function deriveStepDisplay(steps: string[], status: StepStatus): StepDisplay;
+export {};

package/dist/utils/utils.js

@@ -1,47 +1,40 @@
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import process from 'node:process';
-import { featurePackages } from '../constants/config.js';
+import { featureDefinitions } from '../constants/config.js';
 export function getProjectFolder(projectName) {
     return join(process.cwd(), projectName);
 }
-/**
- * Utility functions for import process
- * @param name
- */
 export function isValidName(name) {
     return /^[a-zA-Z0-9_]+$/.test(name);
 }
-/**
- * Checks if the answer is confirmed
- * @param answer
- * @param errorMessage
- */
 export function isAnswerConfirmed(answer, errorMessage) {
     return (answer !== '' && answer !== undefined && (errorMessage === '' || errorMessage === undefined));
 }
-/**
- * Checks if the step can be shown
- * @param currentStep
- * @param stepToShow
- */
 export function canShowStep(currentStep, stepToShow) {
     return currentStep > stepToShow - 1;
 }
-/**
- * Returns true a feature is selected in the features list
- * @param feature
- * @param featuresList
- */
-export function featureSelected(feature, featuresList) {
-    return !!featuresList?.find((item) => item.value === feature);
-}
-/**
- * Returns the packages to remove checking first if the feature is selected or not.
- * Selected features are kept, unselected features are removed.
- * @param feature
- * @param featuresList
- */
-export function getPackages(feature, featuresList) {
-    const packages = featurePackages[feature];
-    return featureSelected(feature, featuresList) ? [] : packages?.length ? packages : [];
+export function isFeatureSelected(feature, selectedFeatures) {
+    return selectedFeatures.includes(feature);
+}
+export function getPackagesToRemove(selectedFeatures) {
+    return Object.entries(featureDefinitions)
+        .filter(([name]) => !selectedFeatures.includes(name))
+        .flatMap(([, def]) => def.packages);
+}
+export function getPostInstallMessages(mode, selectedFeatures) {
+    if (mode === 'full') {
+        return Object.values(featureDefinitions).flatMap((def) => def.postInstall ?? []);
+    }
+    return selectedFeatures.flatMap((name) => featureDefinitions[name]?.postInstall ?? []);
+}
+export function projectDirectoryExists(projectName) {
+    return existsSync(getProjectFolder(projectName));
+}
+export function deriveStepDisplay(steps, status) {
+    return {
+        completedSteps: status === 'done' ? steps : steps.slice(0, -1),
+        currentStep: status === 'running' ? steps.at(-1) : undefined,
+        failedStep: status === 'error' ? steps.at(-1) : undefined,
+    };
 }

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "dappbooster",
-  "version": "3.0.2",
+  "version": "3.1.4",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BootNodeDev/dAppBoosterInstallScript"
+  },
   "bin": "dist/cli.js",
   "type": "module",
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "pnpm biome check",
+    "lint:fix": "pnpm biome check --write"
+  },
   "files": [
     "dist"
   ],
@@ -18,8 +30,8 @@
     "ink-gradient": "^3.0.0",
     "ink-link": "^4.1.0",
     "ink-select-input": "^6.2.0",
-    "ink-spawn": "^0.1.4",
     "ink-text-input": "^6.0.0",
+    "meow": "^14.1.0",
     "react": "^18.3.1"
   },
   "devDependencies": {
@@ -27,13 +39,14 @@
     "@sindresorhus/tsconfig": "^7.0.0",
     "@types/node": "^22.15.21",
     "@types/react": "^18.3.22",
+    "@vitest/coverage-v8": "^4.1.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.0"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "lint": "pnpm biome check",
-    "lint:fix": "pnpm biome check --write"
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@biomejs/biome"
+    ]
   }
-}
+}

package/readme.md

@@ -17,6 +17,106 @@ pnpm dlx dappbooster
 
 dAppBooster documentation: https://docs.dappbooster.dev/
 
+## Non-interactive / CI mode
+
+The installer supports a non-interactive mode for CI pipelines and AI agents. It activates automatically when stdout is not a TTY, or explicitly with the `--ni` flag.
+
+### Discover available features
+
+```shell
+pnpm dlx dappbooster --info
+```
+
+```json
+{
+  "features": {
+    "demo": {
+      "description": "Component demos and example pages",
+      "default": true
+    },
+    "subgraph": {
+      "description": "TheGraph subgraph integration",
+      "default": true,
+      "postInstall": [
+        "Provide your own API key for PUBLIC_SUBGRAPHS_API_KEY in .env.local",
+        "Run pnpm subgraph-codegen from the project folder"
+      ]
+    },
+    "typedoc": {
+      "description": "TypeDoc API documentation generation",
+      "default": true
+    },
+    "vocs": {
+      "description": "Vocs documentation site",
+      "default": true
+    },
+    "husky": {
+      "description": "Git hooks with Husky, lint-staged, and commitlint",
+      "default": true
+    }
+  },
+  "modes": {
+    "full": "Install all features",
+    "custom": "Choose features individually"
+  }
+}
+```
+
+### Full install
+
+```shell
+pnpm dlx dappbooster --ni --name my_dapp --mode full
+```
+
+```json
+{
+  "success": true,
+  "projectName": "my_dapp",
+  "mode": "full",
+  "features": ["demo", "subgraph", "typedoc", "vocs", "husky"],
+  "path": "/absolute/path/to/my_dapp",
+  "postInstall": [
+    "Provide your own API key for PUBLIC_SUBGRAPHS_API_KEY in .env.local",
+    "Run pnpm subgraph-codegen from the project folder"
+  ]
+}
+```
+
+### Custom install with selected features
+
+```shell
+pnpm dlx dappbooster --ni --name my_dapp --mode custom --features demo,subgraph
+```
+
+```json
+{
+  "success": true,
+  "projectName": "my_dapp",
+  "mode": "custom",
+  "features": ["demo", "subgraph"],
+  "path": "/absolute/path/to/my_dapp",
+  "postInstall": [
+    "Provide your own API key for PUBLIC_SUBGRAPHS_API_KEY in .env.local",
+    "Run pnpm subgraph-codegen from the project folder"
+  ]
+}
+```
+
+### Error handling
+
+Errors return structured JSON with a non-zero exit code:
+
+```shell
+pnpm dlx dappbooster --ni --mode full
+```
+
+```json
+{
+  "success": false,
+  "error": "Missing required flag: --name"
+}
+```
+
 ## Development
 
 Clone the repo

package/dist/components/steps/CloneRepo/Commands.d.ts

@@ -1,12 +0,0 @@
-import type { FC } from 'react';
-interface Props {
-    projectName: string;
-    onCompletion: () => void;
-}
-/**
- * Executes all the commands to clone the dAppBooster repository.
- * @param projectName
- * @param onCompletion
- */
-declare const Commands: FC<Props>;
-export default Commands;

package/dist/components/steps/CloneRepo/Commands.js

@@ -1,16 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { join } from 'node:path';
-import * as process from 'node:process';
-import { Box, Text } from 'ink';
-import { Script, Spawn } from 'ink-spawn';
-import { repoUrl } from '../../../constants/config.js';
-/**
- * Executes all the commands to clone the dAppBooster repository.
- * @param projectName
- * @param onCompletion
- */
-const Commands = ({ projectName, onCompletion }) => {
-    const projectFolder = join(process.cwd(), projectName);
-    return (_jsx(Box, { flexDirection: 'column', gap: 0, children: _jsxs(Script, { children: [_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: 'whiteBright', children: "Cloning dAppBooster in" }), _jsx(Text, { italic: true, children: projectName })] }), _jsx(Spawn, { shell: true, silent: true, successText: 'Done!', failureText: `Failed to clone the project, check if a folder called "${projectName}" already exists and your read/write permissions...`, runningText: 'Working...', command: "git", args: ['clone', '--depth', '1', '--no-checkout', repoUrl, projectName] }), _jsx(Text, { color: 'whiteBright', children: "Fetching tags" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'git', args: ['fetch', '--tags'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...' }), _jsx(Text, { color: 'whiteBright', children: "Checking out latest tag" }), _jsx(Spawn, { shell: true, cwd: projectFolder, command: "git", args: ['checkout $(git describe --tags `git rev-list --tags --max-count=1`)'], successText: "Done!", failureText: 'Error...' }), _jsx(Text, { color: 'whiteBright', children: "Removing .git folder" }), _jsx(Spawn, { shell: true, cwd: projectFolder, command: "rm", args: ['-rf', '.git'], successText: "Done!", failureText: 'Error...' }), _jsx(Text, { color: 'whiteBright', children: "Initializing Git repository" }), _jsx(Spawn, { shell: true, cwd: projectFolder, command: "git", args: ['init'], successText: "Done!", failureText: 'Error...', onCompletion: onCompletion })] }) }));
-};
-export default Commands;

package/dist/components/steps/Install/CustomInstallation.d.ts

@@ -1,16 +0,0 @@
-import type { FC } from 'react';
-import type { MultiSelectItem } from '../../../types/types.js';
-interface Props {
-    onCompletion: () => void;
-    projectFolder: string;
-    selectedFeatures?: Array<MultiSelectItem>;
-}
-/**
- * Performs a custom installation based on the selected features: basically we tell `pnpm` what
- * features to remove (everything's included in package.json by default to simplify things)
- * @param onCompletion
- * @param selectedFeatures
- * @param projectFolder
- */
-declare const CustomInstallation: FC<Props>;
-export default CustomInstallation;

package/dist/components/steps/Install/CustomInstallation.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { Script, Spawn } from 'ink-spawn';
-import { getPackages } from '../../../utils/utils.js';
-import InstallAllPackages from './InstallAllPackages.js';
-/**
- * Performs a custom installation based on the selected features: basically we tell `pnpm` what
- * features to remove (everything's included in package.json by default to simplify things)
- * @param onCompletion
- * @param selectedFeatures
- * @param projectFolder
- */
-const CustomInstallation = ({ onCompletion, selectedFeatures, projectFolder }) => {
-    // Collects the packages to remove based on the selected features and makes
-    // a string out of them so that we can pass it to `pnpm remove` command.
-    const packagesToRemove = [
-        ...getPackages('subgraph', selectedFeatures),
-        ...getPackages('typedoc', selectedFeatures),
-        ...getPackages('vocs', selectedFeatures),
-        ...getPackages('husky', selectedFeatures),
-    ]
-        .join(' ')
-        .trim();
-    return (_jsx(Box, { flexDirection: 'column', gap: 0, children: !packagesToRemove ? (_jsx(Script, { children: _jsx(InstallAllPackages, { projectFolder: projectFolder, onCompletion: onCompletion }) })) : (_jsxs(Script, { children: [_jsx(Text, { color: 'whiteBright', children: "Installing packages" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'pnpm', args: ['remove', packagesToRemove], runningText: 'Working...', successText: 'Done!', failureText: 'Error...' }), _jsx(Text, { color: 'whiteBright', children: "Executing post-install scripts" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'pnpm', args: ['run', 'postinstall'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...', onCompletion: onCompletion })] })) }));
-};
-export default CustomInstallation;

package/dist/components/steps/Install/FullInstallation.d.ts

@@ -1,7 +0,0 @@
-import type { FC } from 'react';
-interface Props {
-    projectFolder: string;
-    onCompletion?: () => void;
-}
-declare const FullInstallation: FC<Props>;
-export default FullInstallation;

package/dist/components/steps/Install/FullInstallation.js

@@ -1,8 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Box } from 'ink';
-import { Script } from 'ink-spawn';
-import InstallAllPackages from './InstallAllPackages.js';
-const FullInstallation = ({ onCompletion, projectFolder }) => {
-    return (_jsx(Box, { flexDirection: 'column', gap: 0, children: _jsx(Script, { children: _jsx(InstallAllPackages, { projectFolder: projectFolder, onCompletion: onCompletion }) }) }));
-};
-export default FullInstallation;

package/dist/components/steps/Install/InstallAllPackages.d.ts

@@ -1,7 +0,0 @@
-import type { FC } from 'react';
-interface Props {
-    onCompletion?: () => void;
-    projectFolder: string;
-}
-declare const InstallAllPackages: FC<Props>;
-export default InstallAllPackages;

package/dist/components/steps/Install/InstallAllPackages.js

@@ -1,7 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { Text } from 'ink';
-import { Spawn } from 'ink-spawn';
-const InstallAllPackages = ({ projectFolder, onCompletion }) => {
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { color: 'whiteBright', children: "Installing packages" }), _jsx(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'pnpm', args: ['i'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...', onCompletion: onCompletion })] }));
-};
-export default InstallAllPackages;