vyriy 0.3.5 → 0.3.8

package/README.md

@@ -36,6 +36,10 @@ vyriy init
 vyriy doctor
 vyriy --dry-run
 vyriy --yes
+vyriy --no-install
+vyriy --no-verify
+vyriy --install-only
+vyriy --verify
 vyriy --overwrite
 vyriy --skip-existing
 vyriy --help
@@ -48,7 +52,7 @@ Runs the same flow as `vyriy new`.
 
 ### `vyriy new [name]`
 
-Starts the project planning wizard, prints the project summary and file plan, then writes generated files when no unresolved conflicts exist.
+Starts the project planning wizard, prints the project summary and file plan, writes generated files when no unresolved conflicts exist, installs dependencies, and runs generated project checks.
 
 If `name` is provided, it is used as the default project name and target directory.
 
@@ -79,11 +83,27 @@ Node.js is fatal when unsupported. Yarn and Git are warnings so generation can c
 
 ### `--dry-run`
 
-Prints the doctor report, project summary, and file plan without writing files or running fix commands.
+Prints the doctor report, project summary, and file plan without writing files, installing dependencies, or running checks.
+
+### `--no-install`
+
+Writes generated files but skips `yarn install` and `yarn check`.
+
+### `--no-verify`
+
+Writes generated files and runs `yarn install`, but skips `yarn check`.
+
+### `--install-only`
+
+Alias for `--no-verify`.
+
+### `--verify`
+
+Explicitly enables `yarn check`. This is already the default unless `--no-install`, `--no-verify`, or `--install-only` is passed.
 
 ### `--yes`
 
-Uses default wizard answers and avoids prompts where possible. It does not overwrite existing files unless `--overwrite` is also passed.
+Uses default wizard answers and avoids prompts where possible. In non-interactive mode, the default preset is `empty` with no CI/CD provider. It does not overwrite existing files unless `--overwrite` is also passed.
 
 ### `--overwrite`
 
@@ -106,10 +126,10 @@ The wizard collects:
 - project preset
 - API style for API-capable presets
 - CI/CD provider
-- optional infrastructure choices
+- infrastructure provider
 - confirmation
 
-After confirmation, the CLI prints the project plan, creates generated files in memory, builds a conflict-aware file plan, and writes the accepted file plan.
+After confirmation, the CLI prints the project plan, creates generated files in memory, builds a conflict-aware file plan, writes the accepted file plan, runs `yarn install`, and runs `yarn check`.
 
 Presets do not write to disk directly.
 
@@ -119,28 +139,28 @@ Generated projects always include `AGENTS.md` based on the shared Vyriy package
 
 Supported presets:
 
+- `empty`
 - `library`
 - `api`
-- `react-csr`
-- `react-ssr`
-- `react-ssg`
-- `mfe`
-- `openmfe`
-- `mfe-bff`
-- `openmfe-bff`
+- `ssr`
+- `ssg`
+- `csr`
 - `fullstack`
-- `aws-serverless`
-- `empty`
+- `mfe`
+
+The preset is the concrete future generated setup. The project kind is the broader architecture category. The infrastructure choice is selected separately: Docker is the default local/container shape, while AWS selects CDK plus Lambda/API Gateway for API-capable presets.
+
+The `mfe` preset uses OpenMFE as the default MFE contract shape. There is no separate `openmfe` preset unless a future use case proves that split is useful.
 
-The preset is the concrete future generated setup. The project kind is the broader architecture category.
+Workspace kinds describe deployment intent: `ui` is universal UI output, `api` is Docker-oriented, `lambda` is the AWS API runtime, `fargate` is an AWS container runtime, and `stack` contains AWS infrastructure.
 
 Examples:
 
-- `react-csr` -> `csr`
-- `react-ssr` -> `ssr`
-- `react-ssg` -> `ssg`
-- `openmfe-bff` -> `mfe`
-- `aws-serverless` -> `aws-serverless`
+- `csr` -> `csr`
+- `ssr` -> `ssr`
+- `ssg` -> `ssg`
+- `mfe` -> `mfe`
+- `fullstack` -> `fullstack`
 
 ## Public API
 
@@ -178,7 +198,7 @@ It includes:
 - architecture: `preset`, `projectKind`
 - selected features
 - CI/CD planning: enabled state, providers, and validation pipelines
-- API planning for API-capable presets: REST, GraphQL, or mixed API style
+- API planning for API-capable presets: REST or GraphQL API style
 - future package plans
 - future workspace plans
 

package/cli/args/args.js

@@ -6,6 +6,8 @@ export const parseArgs = (args) => {
         return { type: 'version' };
     }
     const dryRun = args.includes('--dry-run');
+    const install = !args.includes('--no-install');
+    const verify = install && (args.includes('--verify') || (!args.includes('--no-verify') && !args.includes('--install-only')));
     const yes = args.includes('--yes') || args.includes('-y');
     const overwrite = args.includes('--overwrite');
     const skipExisting = args.includes('--skip-existing');
@@ -13,8 +15,10 @@ export const parseArgs = (args) => {
     const [command, projectName] = positionalArgs;
     const options = {
         dryRun,
+        install,
         yes,
         overwrite,
+        verify,
         skipExisting,
     };
     if (!command) {

package/cli/args/types.d.ts

@@ -2,14 +2,18 @@ export type VyriyCliCommand = {
     readonly type: 'new';
     readonly projectName?: string;
     readonly dryRun: boolean;
+    readonly install: boolean;
     readonly yes: boolean;
     readonly overwrite: boolean;
+    readonly verify: boolean;
     readonly skipExisting: boolean;
 } | {
     readonly type: 'init';
     readonly dryRun: boolean;
+    readonly install: boolean;
     readonly yes: boolean;
     readonly overwrite: boolean;
+    readonly verify: boolean;
     readonly skipExisting: boolean;
 } | {
     readonly type: 'doctor' | 'help' | 'version';

package/cli/cli.js

@@ -10,9 +10,16 @@ Usage:
   vyriy init             Initialize the current directory
   vyriy .                Initialize the current directory
   vyriy doctor           Check local environment
+  vyriy --yes, -y        Use defaults where possible (empty preset)
   vyriy --dry-run        Print checks and file plan without writing
-  vyriy --help           Show help
-  vyriy --version        Show version
+  vyriy --overwrite      Overwrite existing generated paths
+  vyriy --skip-existing  Leave existing generated paths untouched
+  vyriy --no-install     Create files without installing dependencies
+  vyriy --no-verify      Install dependencies without running checks
+  vyriy --install-only   Alias for --no-verify
+  vyriy --verify         Explicitly enable generated project checks
+  vyriy --help, -h       Show help
+  vyriy --version, -v    Show version
 
 Examples:
   vyriy new my-app
@@ -25,19 +32,23 @@ export const runVyriyCli = async (args = [], { output = console } = {}) => {
         case 'new':
             code = await runNewCommand({
                 dryRun: command.dryRun,
+                install: command.install,
                 output,
                 overwrite: command.overwrite,
                 projectName: command.projectName,
                 skipExisting: command.skipExisting,
+                verify: command.verify,
                 yes: command.yes,
             });
             break;
         case 'init':
             code = await runInitCommand({
                 dryRun: command.dryRun,
+                install: command.install,
                 output,
                 overwrite: command.overwrite,
                 skipExisting: command.skipExisting,
+                verify: command.verify,
                 yes: command.yes,
             });
             break;

package/commands/new/new.js

@@ -5,6 +5,8 @@ import { createFilePlan, printFilePlan, writeFilePlan } from '../../file-plan/in
 import { createProjectFiles } from '../../presets/index.js';
 import { askProjectPlan as askProjectPlanDefault } from '../../prompts/project-plan/index.js';
 import { createProjectPlanFromPreset, printProjectPlan } from '../../project-plan/index.js';
+import { runCommand } from '../../shared/index.js';
+const defaultYesPreset = 'empty';
 const getConflicts = (filePlan) => filePlan.filter((item) => item.status === 'conflict');
 const logConflicts = (output, conflicts, method) => {
     output[method]('\nExisting files found:\n');
@@ -28,6 +30,70 @@ const createResolvedFilePlan = async (plan, projectFiles, resolution) => createF
     overwrite: resolution === 'overwrite',
     skipExisting: resolution === 'skip',
 });
+const formatCommand = (command, args) => [command, ...args].join(' ');
+const printFailedPostGenerationCommand = ({ args, command, intro, output, projectDirectory, }) => {
+    const commandText = formatCommand(command, args);
+    output.error(`\n${intro}\n`);
+    output.error(`Failed command:\n  ${commandText}\n`);
+    output.error(`Project directory:\n  ${projectDirectory}\n`);
+    output.error(`You can inspect it and run manually:\n  cd ${projectDirectory}\n  ${commandText}`);
+};
+const runPostGenerationCommands = async ({ install, output, projectDirectory, verify, }) => {
+    if (!install) {
+        output.log('Installing dependencies... SKIPPED');
+        output.log('Running checks... SKIPPED');
+        output.log('\nProject files were created.');
+        return 0;
+    }
+    try {
+        await runCommand({
+            args: ['install'],
+            command: 'yarn',
+            cwd: projectDirectory,
+        });
+    }
+    catch {
+        printFailedPostGenerationCommand({
+            args: ['install'],
+            command: 'yarn',
+            intro: 'Project files were created, but dependency installation failed.',
+            output,
+            projectDirectory,
+        });
+        return 1;
+    }
+    output.log('Installing dependencies... OK');
+    if (!verify) {
+        output.log('Running checks... SKIPPED');
+        output.log('\nProject files were created and dependencies were installed.');
+        return 0;
+    }
+    try {
+        await runCommand({
+            args: ['fix'],
+            command: 'yarn',
+            cwd: projectDirectory,
+        });
+        await runCommand({
+            args: ['check'],
+            command: 'yarn',
+            cwd: projectDirectory,
+        });
+    }
+    catch {
+        printFailedPostGenerationCommand({
+            args: ['check'],
+            command: 'yarn',
+            intro: 'Project files were created and dependencies were installed, but verification failed.',
+            output,
+            projectDirectory,
+        });
+        return 1;
+    }
+    output.log('Running checks... OK');
+    output.log('\nProject is ready.');
+    return 0;
+};
 const resolveInteractiveConflicts = async (plan, projectFiles, output, conflicts, askConflictResolution) => {
     logConflicts(output, conflicts, 'log');
     printConflictPrompt(output);
@@ -46,7 +112,7 @@ const resolveInteractiveConflicts = async (plan, projectFiles, output, conflicts
 export const askConflictResolutionDefault = async () => {
     const readline = createInterface({ input: stdin, output: stdout });
     try {
-        const answer = (await readline.question('What should Vyriy do? 1. overwrite existing files, 2. skip existing files, 3. abort (abort): '))
+        const answer = (await readline.question('What should Vyriy do?\n\n 1. overwrite existing files,\n\n 2. skip existing files,\n\n 3. abort (abort): '))
             .trim()
             .toLowerCase();
         if (answer === '1' || answer === 'overwrite') {
@@ -61,7 +127,7 @@ export const askConflictResolutionDefault = async () => {
         readline.close();
     }
 };
-export const runNewCommand = async ({ askConflictResolution = askConflictResolutionDefault, askProjectPlan = askProjectPlanDefault, dryRun = false, output = console, overwrite = false, projectName = 'my-app', skipExisting = false, yes = false, } = {}) => {
+export const runNewCommand = async ({ askConflictResolution = askConflictResolutionDefault, askProjectPlan = askProjectPlanDefault, dryRun = false, install = true, output = console, overwrite = false, projectName = 'my-app', skipExisting = false, verify = true, yes = false, } = {}) => {
     if (overwrite && skipExisting) {
         output.error('Cannot use --overwrite and --skip-existing together.');
         return 1;
@@ -72,13 +138,13 @@ export const runNewCommand = async ({ askConflictResolution = askConflictResolut
         output.error('\nPlease install Node.js 24+ and run the command again.');
         return 1;
     }
-    const plan = dryRun || yes
+    const plan = yes
         ? createProjectPlanFromPreset({
             apiStyle: 'rest',
             ciProvider: 'none',
             description: 'Calm cloud-ready application.',
             packageScope: `@${projectName}`,
-            preset: 'react-ssr',
+            preset: defaultYesPreset,
             projectName,
             targetDirectory: projectName,
         })
@@ -113,6 +179,11 @@ export const runNewCommand = async ({ askConflictResolution = askConflictResolut
         output.log(`\n${printFilePlan(resolved.filePlan)}`);
     }
     await writeFilePlan(plan.targetDirectory, filePlan);
-    output.log('\nProject files written.');
-    return 0;
+    output.log('\nCreating project files... OK');
+    return runPostGenerationCommands({
+        install,
+        output,
+        projectDirectory: plan.targetDirectory,
+        verify: install && verify,
+    });
 };

package/commands/new/types.d.ts

@@ -6,8 +6,10 @@ export type RunNewCommandOptions = {
     readonly askConflictResolution?: () => Promise<ConflictResolution>;
     readonly output?: Pick<typeof console, 'log' | 'error'>;
     readonly dryRun?: boolean;
+    readonly install?: boolean;
     readonly yes?: boolean;
     readonly overwrite?: boolean;
+    readonly verify?: boolean;
     readonly skipExisting?: boolean;
 };
 export type RunNewCommand = (options?: RunNewCommandOptions) => Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vyriy",
-  "version": "0.3.5",
+  "version": "0.3.8",
   "description": "Interactive project master for calm cloud-ready applications.",
   "type": "module",
   "main": "./index.js",
@@ -489,6 +489,16 @@
       "import": "./shared/index.js",
       "default": "./shared/index.js"
     },
+    "./shared/runCommand": {
+      "types": "./shared/runCommand.d.ts",
+      "import": "./shared/runCommand.js",
+      "default": "./shared/runCommand.js"
+    },
+    "./shared/runCommand.js": {
+      "types": "./shared/runCommand.d.ts",
+      "import": "./shared/runCommand.js",
+      "default": "./shared/runCommand.js"
+    },
     "./shared/semver": {
       "types": "./shared/semver.d.ts",
       "import": "./shared/semver.js",

package/presets/createProjectFiles.js

@@ -1,42 +1,94 @@
 import { agentsTemplate } from './agentsTemplate.js';
+import rootPackageJson from '../../../package.json' with { type: 'json' };
 const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
-const createRootPackageJson = ({ description, packageScope, projectName, }) => ({
+const packageVersion = (version) => `^${version}`;
+const baseRootDevDependencies = {
+    '@vyriy/typescript-config': packageVersion(rootPackageJson.version),
+    typescript: rootPackageJson.dependencies.typescript,
+    '@vyriy/prettier-config': packageVersion(rootPackageJson.version),
+    prettier: rootPackageJson.dependencies.prettier,
+    '@vyriy/eslint-config': packageVersion(rootPackageJson.version),
+    eslint: rootPackageJson.dependencies.eslint,
+    '@vyriy/jest-config': packageVersion(rootPackageJson.version),
+    jest: rootPackageJson.dependencies.jest,
+    '@vyriy/storybook-config': packageVersion(rootPackageJson.version),
+    storybook: rootPackageJson.dependencies.storybook,
+    '@vyriy/path': packageVersion(rootPackageJson.version),
+    husky: rootPackageJson.dependencies.husky,
+    'npm-run-all2': rootPackageJson.dependencies['npm-run-all2'],
+    'cross-env': rootPackageJson.dependencies['cross-env'],
+};
+const stylelintDevDependencies = {
+    '@vyriy/stylelint-config': packageVersion(rootPackageJson.version),
+    stylelint: rootPackageJson.dependencies.stylelint,
+};
+const createRootPackageJson = ({ description, packageScope, projectName, stylelint, }) => ({
     path: 'package.json',
     content: json({
         name: `${packageScope}/${projectName}`,
-        version: '0.1.0',
+        version: '0.0.0',
         description,
         private: true,
         type: 'module',
-        packageManager: 'yarn@4.14.1',
+        packageManager: rootPackageJson.packageManager,
         engines: {
-            node: '>=24.0.0',
+            node: rootPackageJson.engines.node,
         },
-        scripts: {
-            lint: 'eslint .',
-            test: 'jest --coverage=false',
-            build: 'tsc --pretty false',
-            deploy: 'echo "Deploy is not configured yet."',
-            smoke: 'echo "Smoke checks are not configured yet."',
-            e2e: 'echo "E2E checks are not configured yet."',
-        },
-        devDependencies: {},
         workspaces: [
             'packages/*',
             'workspaces/*',
         ],
+        scripts: {
+            storybook: 'cross-env STORYBOOK_DISABLE_TELEMETRY=1 storybook dev -p 6006 --disable-telemetry',
+            check: 'run-s lint build test',
+            fix: "run-s 'fix:*'",
+            lint: "run-s 'lint:*'",
+            build: "run-s 'build:*'",
+            test: "run-s 'test:*'",
+            'fix:prettier': 'prettier . --write',
+            'fix:eslint': 'eslint . --fix',
+            'lint:ts': 'tsc --pretty false',
+            'lint:prettier': 'prettier . --check',
+            'lint:eslint': 'eslint .',
+            ...(stylelint ? { 'lint:stylelint': 'stylelint "packages/**/*.{scss,css}"' } : {}),
+            'build:dist': 'echo "Build dist is not configured yet."',
+            'build:storybook': 'cross-env STORYBOOK_DISABLE_TELEMETRY=1 storybook build --quiet --disable-telemetry',
+            'test:jest': 'jest --passWithNoTests',
+            postinstall: 'husky',
+        },
+        devDependencies: {
+            ...baseRootDevDependencies,
+            ...(stylelint ? stylelintDevDependencies : {}),
+        },
     }),
 });
 const createPackageManifest = ({ packageScope, workspaceName, }) => ({
     path: `packages/${workspaceName}/package.json`,
     content: json({
         name: `${packageScope}/${workspaceName}`,
-        version: '0.1.0',
+        version: '0.0.0',
         private: true,
         type: 'module',
         main: 'index.js',
     }),
 });
+const getWorkspacePath = (workspacePlan) => workspacePlan.kind === 'lambda' && workspacePlan.name === 'api'
+    ? `workspaces/lambda/${workspacePlan.name}`
+    : `workspaces/${workspacePlan.name}`;
+const getWorkspacePackageName = ({ packageScope, workspacePlan, }) => workspacePlan.kind === 'lambda' && workspacePlan.name === 'api'
+    ? `${packageScope}/lambda-api-workspace`
+    : `${packageScope}/${workspacePlan.name}-workspace`;
+const isApiWorkspace = (workspacePlan) => [
+    'api',
+    'lambda',
+    'fargate',
+].includes(workspacePlan.kind);
+const createApiWorkspaceDependencies = (workspacePlan) => isApiWorkspace(workspacePlan)
+    ? {
+        '@vyriy/handler': packageVersion(rootPackageJson.version),
+        '@vyriy/server': packageVersion(rootPackageJson.version),
+    }
+    : {};
 const createPackageFiles = (plan, packagePlan) => [
     createPackageManifest({
         packageScope: plan.packageScope,
@@ -72,39 +124,109 @@ const createPackageFiles = (plan, packagePlan) => [
             },
         ]),
 ];
-const createWorkspaceFiles = (plan, workspacePlan) => [
-    {
-        path: `workspaces/${workspacePlan.name}/package.json`,
-        content: json({
-            name: `${plan.packageScope}/${workspacePlan.name}-workspace`,
-            version: '0.1.0',
-            private: true,
-            type: 'module',
-            main: 'index.js',
-        }),
-    },
-    {
-        path: `workspaces/${workspacePlan.name}/index.ts`,
-        content: 'export type WorkspaceName = string;\n',
-    },
-    {
-        path: `workspaces/${workspacePlan.name}/${workspacePlan.name}.test.ts`,
-        content: "import { describe, expect, it } from '@jest/globals';\n\ndescribe('workspace', () => {\n  it('has a test harness', () => {\n    expect(true).toBe(true);\n  });\n});\n",
-    },
-];
+const createApiHandlerFile = (workspacePath) => ({
+    path: `${workspacePath}/handler.ts`,
+    content: `import { api } from '@vyriy/handler';
+
+export const handler = api(async (event) => ({
+  statusCode: 200,
+  body: JSON.stringify({
+    path: event.path,
+  }),
+}));
+`,
+});
+const createApiServerFile = ({ entrypoint, workspacePath, }) => ({
+    path: `${workspacePath}/${entrypoint}`,
+    content: `import { server } from '@vyriy/server';
+
+import { handler } from './handler.js';
+
+server(handler);
+`,
+});
+const createDockerfile = (workspacePath) => ({
+    path: `${workspacePath}/Dockerfile`,
+    content: `FROM node:24-alpine
+
+WORKDIR /app
+
+COPY package.json yarn.lock .yarnrc.yml ./
+COPY .yarn ./.yarn
+COPY packages ./packages
+COPY workspaces ./workspaces
+
+RUN corepack enable && yarn install --immutable
+RUN yarn build
+
+CMD ["node", "workspaces/api/index.js"]
+`,
+});
+const createApiWorkspaceFiles = (plan, workspacePlan) => {
+    const workspacePath = getWorkspacePath(workspacePlan);
+    const isLambda = workspacePlan.kind === 'lambda';
+    return [
+        createApiHandlerFile(workspacePath),
+        createApiServerFile({ entrypoint: isLambda ? 'server.ts' : 'index.ts', workspacePath }),
+        {
+            path: `${workspacePath}/${workspacePlan.name}.test.ts`,
+            content: "import { describe, expect, it } from '@jest/globals';\n\nimport { handler } from './handler.js';\n\ndescribe('api workspace', () => {\n  it('exports a handler', () => {\n    expect(handler).toEqual(expect.any(Function));\n  });\n});\n",
+        },
+        ...(plan.features.includes('docker') && !isLambda ? [createDockerfile(workspacePath)] : []),
+    ];
+};
+const createWorkspaceFiles = (plan, workspacePlan) => {
+    const workspacePath = getWorkspacePath(workspacePlan);
+    const dependencies = createApiWorkspaceDependencies(workspacePlan);
+    return [
+        {
+            path: `${workspacePath}/package.json`,
+            content: json({
+                name: getWorkspacePackageName({ packageScope: plan.packageScope, workspacePlan }),
+                version: '0.0.0',
+                private: true,
+                type: 'module',
+                main: workspacePlan.kind === 'lambda' ? 'server.js' : 'index.js',
+                ...(Object.keys(dependencies).length > 0 ? { dependencies } : {}),
+            }),
+        },
+        ...(isApiWorkspace(workspacePlan)
+            ? createApiWorkspaceFiles(plan, workspacePlan)
+            : [
+                {
+                    path: `${workspacePath}/index.ts`,
+                    content: 'export type WorkspaceName = string;\n',
+                },
+                {
+                    path: `${workspacePath}/${workspacePlan.name}.test.ts`,
+                    content: "import { describe, expect, it } from '@jest/globals';\n\ndescribe('workspace', () => {\n  it('has a test harness', () => {\n    expect(true).toBe(true);\n  });\n});\n",
+                },
+            ]),
+    ];
+};
 const shouldCreateStylelintConfig = (plan) => plan.features.some((feature) => [
     'react',
     'webpack',
 ].includes(feature));
+const getStylePackageName = (plan) => plan.packages.find((packagePlan) => packagePlan.kind === 'ui')?.name ?? 'ui';
 export const createProjectFiles = (plan) => [
-    createRootPackageJson(plan),
+    createRootPackageJson({
+        ...plan,
+        stylelint: shouldCreateStylelintConfig(plan),
+    }),
     {
         path: 'README.md',
         content: `# ${plan.projectName}\n\n${plan.description}\n`,
     },
     {
         path: 'doc.mdx',
-        content: "import { Meta, Markdown } from '@storybook/addon-docs/blocks';\nimport ReadMe from './README.md?raw';\n\n<Meta title=\"Project/README\" />\n\n<Markdown>{ReadMe}</Markdown>\n",
+        content: `import { Meta, Markdown } from '@storybook/addon-docs/blocks';
+import ReadMe from './README.md?raw';
+
+<Meta title="${plan.projectName}" />
+
+<Markdown>{ReadMe}</Markdown>
+`,
     },
     {
         path: 'AGENTS.md',
@@ -112,11 +234,64 @@ export const createProjectFiles = (plan) => [
     },
     {
         path: '.editorconfig',
-        content: 'root = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ninsert_final_newline = true\nindent_style = space\nindent_size = 2\n',
+        content: `# https://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+indent_style = space
+indent_size = 2
+
+max_line_length = 100
+
+# Markdown
+[*.md]
+trim_trailing_whitespace = false
+max_line_length = off
+
+# YAML / YML
+[*.{yml,yaml}]
+indent_size = 2
+
+# JSON
+[*.json]
+indent_size = 2
+
+# TypeScript / JavaScript
+[*.{ts,tsx,js,jsx}]
+indent_size = 2
+
+# Shell / Bash
+[*.sh]
+indent_size = 2`,
     },
     {
         path: '.gitignore',
-        content: 'node_modules/\ndist/\ncoverage/\n.yarn/cache/\n.env\n',
+        content: `.yarn/*
+!.yarn/cache
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+.DS_Store
+.idea
+node_modules
+coverage
+dist
+storybook-static
+*storybook.log
+consumer
+
+cdk.out
+cdk.context.json
+
+!/**/.gitkeep`,
     },
     {
         path: '.npmrc',
@@ -124,12 +299,50 @@ export const createProjectFiles = (plan) => [
     },
     {
         path: '.nvmrc',
-        content: '24\n',
+        content: 'lts/krypton',
     },
     {
         path: '.yarnrc.yml',
         content: 'nodeLinker: node-modules\n',
     },
+    {
+        path: '.husky/commit-msg',
+        content: '#!/bin/sh\n',
+    },
+    {
+        path: '.husky/post-checkout',
+        content: '#!/bin/sh\n\nyarn\n',
+    },
+    {
+        path: '.husky/post-merge',
+        content: '#!/bin/sh\n\nyarn\n',
+    },
+    {
+        path: '.husky/pre-commit',
+        content: '#!/bin/sh\n\nyarn check\n',
+    },
+    {
+        path: '.husky/pre-push',
+        content: '#!/bin/sh\n\nyarn check\n',
+    },
+    {
+        path: '.storybook/main.ts',
+        content: `import config from '@vyriy/storybook-config';
+import { path } from '@vyriy/path';
+
+export default {
+  ...config,
+  stories: [
+    path('**/*.mdx'),
+    path('**/*.stories.@(js|jsx|mjs|ts|tsx)'),
+  ],
+};
+`,
+    },
+    {
+        path: '.storybook/preview.tsx',
+        content: "export { default } from '@vyriy/storybook-config/preview';\n",
+    },
     {
         path: 'yarn.lock',
         content: '',
@@ -138,10 +351,9 @@ export const createProjectFiles = (plan) => [
         path: 'tsconfig.json',
         content: json({
             extends: '@vyriy/typescript-config/index.json',
-            compilerOptions: {
-                noEmit: false,
-            },
             include: [
+                '.storybook/**/*.ts',
+                '.storybook/**/*.tsx',
                 'packages/**/*.ts',
                 'packages/**/*.tsx',
                 'workspaces/**/*.ts',
@@ -172,6 +384,23 @@ export const createProjectFiles = (plan) => [
                 path: 'stylelint.config.ts',
                 content: "export { default } from '@vyriy/stylelint-config';\n",
             },
+            {
+                path: `packages/${getStylePackageName(plan)}/reset.scss`,
+                content: `html {
+  box-sizing: border-box;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: inherit;
+}
+
+body {
+  margin: 0;
+}
+`,
+            },
         ]
         : []),
     ...plan.packages.flatMap((packagePlan) => createPackageFiles(plan, packagePlan)),

package/project-plan/api/api.js

@@ -1,30 +1,25 @@
 const apiPresets = [
     'api',
     'fullstack',
-    'mfe-bff',
-    'openmfe-bff',
-    'aws-serverless',
+    'mfe',
 ];
 export const isApiPreset = (preset) => apiPresets.includes(preset);
-export const getApiRuntimeFromPreset = (preset) => preset === 'aws-serverless' ? 'lambda' : 'node';
-export const getDefaultApiStyleFromPreset = (preset) => preset === 'openmfe-bff' ? 'mixed' : 'rest';
+export const getApiRuntimeFromPreset = () => 'docker';
+export const getDefaultApiStyleFromPreset = () => 'rest';
 export const getFeaturesFromApiPlan = (api) => {
     if (!api) {
         return [];
     }
-    if (api.style === 'mixed') {
-        return ['rest-api', 'graphql-api'];
-    }
     return api.style === 'rest' ? ['rest-api'] : ['graphql-api'];
 };
-export const createApiPlan = ({ preset, style = getDefaultApiStyleFromPreset(preset) }) => {
+export const createApiPlan = ({ preset, runtime = getApiRuntimeFromPreset(preset), style = getDefaultApiStyleFromPreset(preset), }) => {
     if (!isApiPreset(preset)) {
         return undefined;
     }
     const basePlan = {
         enabled: true,
         style,
-        runtime: getApiRuntimeFromPreset(preset),
+        runtime,
     };
     const restPlan = {
         rest: {
@@ -37,13 +32,6 @@ export const createApiPlan = ({ preset, style = getDefaultApiStyleFromPreset(pre
             packageName: 'graphql',
         },
     };
-    if (style === 'mixed') {
-        return {
-            ...basePlan,
-            ...restPlan,
-            ...graphqlPlan,
-        };
-    }
     return style === 'rest'
         ? {
             ...basePlan,

package/project-plan/api/types.d.ts

@@ -1,6 +1,7 @@
 import { VyriyApiPlan, VyriyApiRuntime, VyriyApiStyle, VyriyFeature, VyriyPreset } from '../types.js';
 export type CreateApiPlanOptions = {
     readonly preset: VyriyPreset;
+    readonly runtime?: VyriyApiRuntime;
     readonly style?: VyriyApiStyle;
 };
 export type CreateApiPlan = (options: CreateApiPlanOptions) => VyriyApiPlan | undefined;

package/project-plan/create/create.js

@@ -9,113 +9,104 @@ const baseFeatures = [
     'storybook',
 ];
 const presetFeatures = {
+    empty: [],
     library: ['react'],
     api: [],
-    'react-csr': ['react', 'webpack'],
-    'react-ssr': ['react', 'webpack'],
-    'react-ssg': ['react', 'webpack'],
-    mfe: ['react', 'webpack'],
-    openmfe: ['react', 'webpack', 'openmfe'],
-    'mfe-bff': ['react', 'webpack', 'bff'],
-    'openmfe-bff': [
-        'react',
-        'webpack',
-        'openmfe',
-        'bff',
-    ],
+    csr: ['react', 'webpack'],
+    ssr: ['react', 'webpack'],
+    ssg: ['react', 'webpack'],
     fullstack: ['react', 'webpack'],
-    'aws-serverless': [
-        'aws-cdk',
-        'lambda',
-        'apigateway',
-    ],
-    empty: [],
+    mfe: ['react', 'webpack', 'openmfe'],
 };
 const packagePlans = {
+    empty: [],
     library: [{ name: 'ui', kind: 'ui', publishable: true }],
     api: [{ name: 'api', kind: 'api', publishable: false }],
-    'react-csr': [
-        { name: 'app', kind: 'core', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-    ],
-    'react-ssr': [
-        { name: 'app', kind: 'core', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'ssr', kind: 'ssr', publishable: false },
-    ],
-    'react-ssg': [
-        { name: 'app', kind: 'core', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'ssg', kind: 'ssg', publishable: false },
-        { name: 'content', kind: 'core', publishable: false },
-    ],
-    mfe: [
-        { name: 'mfe', kind: 'mfe', publishable: false },
-        { name: 'ui', kind: 'ui', publishable: true },
-    ],
-    openmfe: [
-        { name: 'mfe', kind: 'mfe', publishable: false },
+    csr: [
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'openmfe-contract', kind: 'contract', publishable: true },
     ],
-    'mfe-bff': [
-        { name: 'mfe', kind: 'mfe', publishable: false },
+    ssr: [
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'bff', kind: 'bff', publishable: false },
+        { name: 'ssr', kind: 'app', publishable: false },
     ],
-    'openmfe-bff': [
-        { name: 'mfe', kind: 'mfe', publishable: false },
+    ssg: [
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
-        { name: 'bff', kind: 'bff', publishable: false },
-        { name: 'openmfe-contract', kind: 'contract', publishable: true },
+        { name: 'ssg', kind: 'app', publishable: false },
+        { name: 'content', kind: 'utils', publishable: false },
     ],
     fullstack: [
-        { name: 'app', kind: 'core', publishable: false },
+        { name: 'app', kind: 'app', publishable: false },
         { name: 'ui', kind: 'ui', publishable: true },
         { name: 'api', kind: 'api', publishable: false },
     ],
-    'aws-serverless': [
+    mfe: [
+        { name: 'mfe', kind: 'app', publishable: false },
+        { name: 'ui', kind: 'ui', publishable: true },
         { name: 'api', kind: 'api', publishable: false },
-        { name: 'stack', kind: 'stack', publishable: false },
+        { name: 'openmfe-contract', kind: 'config', publishable: true },
     ],
-    empty: [],
 };
 const workspacePlans = {
+    empty: [],
     library: [],
     api: [{ name: 'api', kind: 'api' }],
-    'react-csr': [{ name: 'web', kind: 'web' }],
-    'react-ssr': [
-        { name: 'ssr', kind: 'ssr' },
-        { name: 'web', kind: 'web' },
-    ],
-    'react-ssg': [
-        { name: 'ssg', kind: 'ssg' },
-        { name: 'web', kind: 'web' },
-    ],
-    mfe: [{ name: 'mfe', kind: 'mfe' }],
-    openmfe: [
-        { name: 'mfe', kind: 'mfe' },
-        { name: 'openmfe', kind: 'openmfe' },
-    ],
-    'mfe-bff': [
-        { name: 'mfe', kind: 'mfe' },
-        { name: 'bff', kind: 'bff' },
+    csr: [{ name: 'web', kind: 'ui' }],
+    ssr: [
+        { name: 'ssr', kind: 'ui' },
+        { name: 'web', kind: 'ui' },
     ],
-    'openmfe-bff': [
-        { name: 'mfe', kind: 'mfe' },
-        { name: 'bff', kind: 'bff' },
-        { name: 'openmfe', kind: 'openmfe' },
+    ssg: [
+        { name: 'ssg', kind: 'ui' },
+        { name: 'web', kind: 'ui' },
     ],
     fullstack: [
-        { name: 'web', kind: 'web' },
+        { name: 'web', kind: 'ui' },
+        { name: 'api', kind: 'api' },
+    ],
+    mfe: [
+        { name: 'mfe', kind: 'ui' },
         { name: 'api', kind: 'api' },
     ],
-    'aws-serverless': [{ name: 'stack', kind: 'stack' }],
-    empty: [],
 };
 const uniqueFeatures = (features) => [...new Set(features)];
+const getApiRuntimeFromFeatures = (features) => features.includes('lambda') ? 'lambda' : 'docker';
+const awsInfrastructureFeatures = [
+    'aws-cdk',
+    'lambda',
+    'fargate',
+    's3',
+    'cloudfront',
+];
+const getApiWorkspaceKindFromFeatures = (features) => {
+    if (features.includes('lambda')) {
+        return 'lambda';
+    }
+    if (features.includes('fargate')) {
+        return 'fargate';
+    }
+    return 'api';
+};
+const createWorkspacePlans = ({ features, preset, }) => {
+    const apiWorkspaceKind = getApiWorkspaceKindFromFeatures(features);
+    const workspaces = workspacePlans[preset].map((workspacePlan) => workspacePlan.name === 'api'
+        ? {
+            ...workspacePlan,
+            kind: apiWorkspaceKind,
+        }
+        : workspacePlan);
+    if (features.some((feature) => awsInfrastructureFeatures.includes(feature))) {
+        return [
+            ...workspaces,
+            { name: 'stack', kind: 'stack' },
+        ];
+    }
+    return workspaces;
+};
 export const createProjectPlanFromPreset = ({ description, apiStyle, ciProvider, features = [], packageScope, preset, projectName, targetDirectory, }) => {
-    const api = createApiPlan({ preset, style: apiStyle });
+    const api = createApiPlan({ preset, runtime: getApiRuntimeFromFeatures(features), style: apiStyle });
     const apiFeatures = getFeaturesFromApiPlan(api);
     return {
         projectName,
@@ -131,7 +122,7 @@ export const createProjectPlanFromPreset = ({ description, apiStyle, ciProvider,
             ...features,
         ]),
         packages: [...packagePlans[preset]],
-        workspaces: [...workspacePlans[preset]],
+        workspaces: createWorkspacePlans({ features, preset }),
         ci: createCiPlan({ provider: ciProvider }),
         ...(api ? { api } : {}),
     };

package/project-plan/kind/kind.js

@@ -1,16 +1 @@
-export const getProjectKindFromPreset = (preset) => {
-    switch (preset) {
-        case 'react-csr':
-            return 'csr';
-        case 'react-ssr':
-            return 'ssr';
-        case 'react-ssg':
-            return 'ssg';
-        case 'openmfe':
-        case 'mfe-bff':
-        case 'openmfe-bff':
-            return 'mfe';
-        default:
-            return preset;
-    }
-};
+export const getProjectKindFromPreset = (preset) => preset;

package/project-plan/types.d.ts

@@ -1,14 +1,14 @@
-export type VyriyProjectKind = 'library' | 'api' | 'csr' | 'ssr' | 'ssg' | 'mfe' | 'fullstack' | 'aws-serverless' | 'empty';
-export type VyriyPreset = 'library' | 'api' | 'react-csr' | 'react-ssr' | 'react-ssg' | 'mfe' | 'openmfe' | 'mfe-bff' | 'openmfe-bff' | 'fullstack' | 'aws-serverless' | 'empty';
-export type VyriyFeature = 'typescript' | 'eslint' | 'prettier' | 'jest' | 'rest-api' | 'graphql-api' | 'react' | 'storybook' | 'webpack' | 'docker' | 'aws-cdk' | 'apigateway' | 'lambda' | 'fargate' | 's3' | 'cloudfront' | 'openmfe' | 'bff';
+export type VyriyProjectKind = 'library' | 'api' | 'csr' | 'ssr' | 'ssg' | 'mfe' | 'fullstack' | 'empty';
+export type VyriyPreset = 'empty' | 'library' | 'api' | 'ssr' | 'ssg' | 'csr' | 'fullstack' | 'mfe';
+export type VyriyFeature = 'typescript' | 'eslint' | 'prettier' | 'jest' | 'rest-api' | 'graphql-api' | 'react' | 'storybook' | 'webpack' | 'docker' | 'aws-cdk' | 'apigateway' | 'lambda' | 'fargate' | 's3' | 'cloudfront' | 'openmfe';
 export type VyriyPackagePlan = {
     readonly name: string;
-    readonly kind: 'core' | 'ui' | 'api' | 'bff' | 'ssr' | 'ssg' | 'mfe' | 'contract' | 'stack';
+    readonly kind: 'core' | 'ui' | 'api' | 'services' | 'stack' | 'config' | 'utils' | 'components' | 'app';
     readonly publishable: boolean;
 };
 export type VyriyWorkspacePlan = {
     readonly name: string;
-    readonly kind: 'web' | 'api' | 'ssr' | 'ssg' | 'storybook' | 'bff' | 'mfe' | 'openmfe' | 'stack';
+    readonly kind: 'api' | 'ui' | 'stack' | 'lambda' | 'fargate';
 };
 export type VyriyCiProvider = 'gitlab' | 'github';
 export type VyriyCiPipeline = 'install' | 'lint' | 'test' | 'build' | 'deploy' | 'smoke' | 'e2e';
@@ -17,8 +17,8 @@ export type VyriyCiPlan = {
     readonly providers: VyriyCiProvider[];
     readonly pipelines: VyriyCiPipeline[];
 };
-export type VyriyApiStyle = 'rest' | 'graphql' | 'mixed';
-export type VyriyApiRuntime = 'node' | 'lambda';
+export type VyriyApiStyle = 'rest' | 'graphql';
+export type VyriyApiRuntime = 'docker' | 'lambda';
 export type VyriyApiPlan = {
     readonly enabled: boolean;
     readonly style: VyriyApiStyle;

package/prompts/project-plan/project-plan.js

@@ -2,25 +2,34 @@ import { stdin, stdout } from 'node:process';
 import { createInterface } from 'node:readline';
 import { createProjectPlanFromPreset, getDefaultApiStyleFromPreset, isApiPreset, } from '../../project-plan/index.js';
 const presets = [
+    'empty',
     'library',
     'api',
-    'react-csr',
-    'react-ssr',
-    'react-ssg',
-    'mfe',
-    'openmfe',
-    'mfe-bff',
-    'openmfe-bff',
+    'ssr',
+    'ssg',
+    'csr',
     'fullstack',
-    'aws-serverless',
-    'empty',
-];
-const extraFeatures = [
-    'docker',
-    'aws-api',
-    'aws-fargate',
-    'aws-static',
+    'mfe',
 ];
+const presetDescriptions = {
+    empty: 'shared tooling without application code',
+    library: 'publishable React package for reusable UI',
+    api: 'REST or GraphQL backend API',
+    ssr: 'server-rendered React application',
+    ssg: 'build-time generated static React site',
+    csr: 'browser-rendered React application',
+    fullstack: 'React frontend with backend API',
+    mfe: 'OpenMFE widget with UI, API, SSR, and manifest',
+};
+const infrastructureOptions = ['docker', 'aws'];
+const infrastructureFeatureMap = {
+    docker: ['docker'],
+    aws: [
+        'aws-cdk',
+        'lambda',
+        'apigateway',
+    ],
+};
 const extraFeatureMap = {
     docker: ['docker'],
     'aws-api': [
@@ -48,7 +57,7 @@ const directFeatureInputs = [
     's3',
     'cloudfront',
 ];
-const apiStyles = ['rest', 'graphql', 'mixed'];
+const apiStyles = ['rest', 'graphql'];
 const ciProviders = ['none', 'gitlab', 'github'];
 const createQuestion = (readline, output) => {
     const queuedLines = [];
@@ -96,6 +105,28 @@ const parseFeatures = (value) => [
             ? [feature]
             : []))),
 ];
+const parseInfrastructure = (value, defaultValue) => {
+    const normalizedValue = value.trim().toLowerCase();
+    const numericValue = Number.parseInt(normalizedValue, 10);
+    if (Number.isInteger(numericValue) && infrastructureOptions[numericValue - 1]) {
+        return [...infrastructureFeatureMap[infrastructureOptions[numericValue - 1]]];
+    }
+    if (infrastructureOptions.includes(normalizedValue)) {
+        return [...infrastructureFeatureMap[normalizedValue]];
+    }
+    const legacyFeatures = parseFeatures(value);
+    return legacyFeatures.length > 0 ? legacyFeatures : [...infrastructureFeatureMap[defaultValue]];
+};
+const getDefaultInfrastructureInput = (features) => features?.some((feature) => [
+    'aws-cdk',
+    'lambda',
+    'apigateway',
+    'fargate',
+    's3',
+    'cloudfront',
+].includes(feature))
+    ? 'aws'
+    : 'docker';
 const parseApiStyle = (value, defaultValue) => {
     const normalizedValue = value.trim().toLowerCase();
     const numericValue = Number.parseInt(normalizedValue, 10);
@@ -124,12 +155,13 @@ export const askProjectPlan = async ({ defaults = {}, input = stdin, output = st
         const packageScope = await promptWithDefault(question, 'Package scope', defaults.packageScope ?? `@${projectName}`);
         const description = await promptWithDefault(question, 'Description', defaults.description ?? 'Calm cloud-ready application.');
         output.write('\nProject preset:\n');
-        presets.forEach((preset, index) => output.write(`  ${index + 1}. ${preset}\n`));
-        const presetAnswer = await promptWithDefault(question, 'Preset number or name', defaults.preset ?? 'react-ssr');
-        const preset = parsePreset(presetAnswer, defaults.preset ?? 'react-ssr');
+        presets.forEach((preset, index) => output.write(`  ${index + 1}. ${preset} - ${presetDescriptions[preset]}\n`));
+        const defaultPreset = defaults.preset ?? 'empty';
+        const presetAnswer = await promptWithDefault(question, 'Preset number or name', defaultPreset);
+        const preset = parsePreset(presetAnswer, defaultPreset);
         const defaultApiStyle = defaults.apiStyle ?? getDefaultApiStyleFromPreset(preset);
         const apiStyle = isApiPreset(preset)
-            ? parseApiStyle(await promptWithDefault(question, 'API style: 1. rest (@vyriy/router), 2. graphql, 3. mixed', defaultApiStyle), defaultApiStyle)
+            ? parseApiStyle(await promptWithDefault(question, 'API style:\n  1. rest (@vyriy/router),\n  2. graphql', defaultApiStyle), defaultApiStyle)
             : undefined;
         output.write('\nCI/CD provider:\n');
         output.write('  1. none\n');
@@ -137,10 +169,12 @@ export const askProjectPlan = async ({ defaults = {}, input = stdin, output = st
         output.write('  3. github\n');
         const defaultCiProvider = defaults.ciProvider ?? 'none';
         const ciProvider = parseCiProvider(await promptWithDefault(question, 'CI/CD provider number or name', defaultCiProvider), defaultCiProvider);
-        output.write('\nAdditional infrastructure, comma-separated:\n');
-        output.write(`  ${extraFeatures.join(', ')}\n`);
-        const featuresAnswer = await promptWithDefault(question, 'Infrastructure', defaults.features?.join(', ') ?? '');
-        const features = parseFeatures(featuresAnswer);
+        output.write('\nInfrastructure:\n');
+        output.write('  1. Docker\n');
+        output.write('  2. AWS\n');
+        const defaultInfrastructure = getDefaultInfrastructureInput(defaults.features);
+        const featuresAnswer = await promptWithDefault(question, 'Infrastructure number or name', defaultInfrastructure);
+        const features = parseInfrastructure(featuresAnswer, defaultInfrastructure);
         const plan = createProjectPlanFromPreset({
             projectName,
             targetDirectory,

package/shared/index.d.ts

@@ -1,5 +1,6 @@
 export * from './commandExists.js';
 export * from './execCommand.js';
 export * from './fileExists.js';
+export * from './runCommand.js';
 export * from './semver.js';
 export type * from './types.js';

package/shared/index.js

@@ -1,4 +1,5 @@
 export * from './commandExists.js';
 export * from './execCommand.js';
 export * from './fileExists.js';
+export * from './runCommand.js';
 export * from './semver.js';

package/shared/runCommand.d.ts

@@ -0,0 +1,9 @@
+import { RunCommand, RunCommandOptions } from './types.js';
+export declare class RunCommandError extends Error {
+    readonly args: readonly string[];
+    readonly command: string;
+    readonly cwd: string;
+    readonly exitCode: number | null;
+    constructor({ args, command, cwd }: RunCommandOptions, exitCode: number | null);
+}
+export declare const runCommand: RunCommand;

package/shared/runCommand.js

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process';
+import { env as processEnv } from 'node:process';
+export class RunCommandError extends Error {
+    args;
+    command;
+    cwd;
+    exitCode;
+    constructor({ args = [], command, cwd }, exitCode) {
+        super(`Command failed with exit code ${exitCode ?? 'unknown'}: ${command} ${args.join(' ')}`.trim());
+        this.name = 'RunCommandError';
+        this.args = args;
+        this.command = command;
+        this.cwd = cwd;
+        this.exitCode = exitCode;
+    }
+}
+export const runCommand = async (options) => {
+    const child = spawn(options.command, [...(options.args ?? [])], {
+        cwd: options.cwd,
+        env: options.env ?? processEnv,
+        shell: false,
+        stdio: 'inherit',
+    });
+    await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new RunCommandError(options, code));
+        });
+    });
+};

package/shared/types.d.ts

@@ -1,4 +1,11 @@
 export type ExecCommand = (command: string, args?: readonly string[]) => Promise<string>;
+export type RunCommandOptions = {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd: string;
+    readonly env?: Record<string, string | undefined>;
+};
+export type RunCommand = (options: RunCommandOptions) => Promise<void>;
 export type CommandExists = (command: string, options?: {
     readonly execCommand?: ExecCommand;
 }) => Promise<boolean>;