@vyriy/tooling 0.8.2

package/AGENTS.md

@@ -0,0 +1,102 @@
+# Project Agent Guide
+
+This repository follows a calm engineering style: changes should be explicit, reusable, typed, documented, tested, and easy to reason about.
+
+Use this guide as the default behavior for AI agents and contributors working in this repository. Prefer local package conventions when they are more specific than this document.
+
+## Core Principles
+
+- Prefer simple modules over clever frameworks or hidden conventions.
+- Keep package and project boundaries explicit.
+- Avoid project-specific coupling in reusable code.
+- Extract only proven reusable behavior.
+- Keep public APIs small, typed, documented, and stable.
+- Prefer SSR-friendly and SSG-friendly code paths when working with frontend or shared code.
+- Keep integrations replaceable and avoid hard coupling to a CMS, framework, vendor, or runtime host.
+- Prefer infrastructure assumptions that are easy to deploy, observe, and replace.
+- Prefer the option that is simpler to explain, easier to evolve, and calmer to maintain.
+
+## File Shape
+
+- Prefer one exported runtime method, component, helper, or class per production file when it stays readable.
+- Prefer one matching test file per production file, for example `feature.ts` and `feature.test.ts`.
+- Use focused folders when behavior naturally splits into several related files.
+- Keep `index.ts` as a public re-export surface only. Do not place implementation logic in it.
+- Use relative import and export specifiers that match the package module style.
+- Use `.js` relative specifiers in TypeScript source for ESM/NodeNext packages.
+- Add `types.ts` when public shared types are part of the package contract.
+- Keep constants near the code that owns them unless they are shared or clarify repeated behavior.
+
+## Public Surface
+
+- Every new public export must be re-exported from the package or module public entry point.
+- Add or update public-surface tests when exports change.
+- Add JSDoc for public exports when behavior, parameters, return values, or usage expectations need explanation.
+- Avoid exporting internal helpers only to make tests easier.
+- Do not hand-maintain package `exports` maps unless the project has a real custom publishing need.
+
+## Tests
+
+- Cover public behavior and meaningful edge cases.
+- Prefer behavior-focused tests over private implementation lock-in.
+- Keep tests deterministic.
+- Avoid real network, filesystem, timers, browser, or cloud dependencies unless the behavior specifically requires them.
+- When mocking modules, install mocks before loading the module under test.
+- Use focused validation when changing behavior.
+
+Example validation commands:
+
+```bash
+yarn test
+```
+
+For workspaces, prefer the project convention, for example:
+
+```bash
+yarn workspace <package-name> test
+```
+
+For Jest-based packages, focused validation may look like:
+
+```bash
+yarn jest packages/<package> --runInBand --coverage=false
+```
+
+## Documentation
+
+- Keep `README.md` concise and usage-oriented.
+- Start package READMEs with `# <package>`.
+- Document real public exports, supported options, and examples that actually work.
+- Update docs when public behavior changes.
+- Keep generated docs wrappers, such as `doc.mdx`, aligned with the README when the project uses them.
+- For component packages, include visual documentation or stories for supported states and common usage.
+
+## Components
+
+- Prefer lightweight React components with TypeScript when working in React packages.
+- Keep components SSR-friendly and avoid browser globals during render.
+- Prefer composable props and predictable ergonomics.
+- Put each public component in its own file with a matching test.
+- Add stories or examples when a component has visual states, variants, or interaction states.
+- Keep styling explicit and reusable. Avoid hidden theme assumptions unless they are part of the package contract.
+
+## Change Discipline
+
+- Keep changes scoped to the requested behavior.
+- Avoid unrelated refactors and metadata churn.
+- Sync implementation, tests, docs, examples, and public re-exports together.
+- Do not introduce new dependencies unless they clearly reduce complexity or are already part of the project direction.
+- Prefer small, reviewable changes over broad rewrites.
+- Preserve existing conventions unless there is a clear reason to change them.
+
+## Before Finishing
+
+Check that the change is complete:
+
+- Public exports are updated.
+- Public-surface tests are updated when exports change.
+- Matching unit tests exist for new behavior.
+- README examples still match the real API.
+- Visual docs, stories, or examples are updated for visible component behavior.
+- TypeScript imports follow the package module style.
+- No unrelated files, formatting churn, or generated artifacts were changed.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyriy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @vyriy/tooling
+
+Part of [Vyriy](https://vyriy.dev) - a calm architecture toolkit for TypeScript, React, SSR, SSG, APIs, and cloud-ready apps.
+
+Full documentation: https://vyriy.dev/docs/tooling/
+
+CLI for generating thin local tooling config files that delegate to shared Vyriy config packages.
+
+## CLI
+
+Install globally:
+
+```bash
+npm install --global @vyriy/tooling
+```
+
+Generate default configs:
+
+```bash
+vyriy-tooling
+vyriy-tooling init
+vt init
+```
+
+Generate one config:
+
+```bash
+vyriy-tooling typescript
+vyriy-tooling eslint
+vyriy-tooling prettier
+vyriy-tooling jest
+vyriy-tooling storybook
+vyriy-tooling stylelint
+```
+
+CLI flags:
+
+- `--force` overwrites existing config files.
+- `--dry-run` prints files that would be created without writing them.
+- `--help` or `-h` prints command help.
+- `--version` or `-v` prints the package version.
+
+After writing files, the CLI prints missing Vyriy config packages that should be installed in the target project.

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runToolingCli } from '../index.js';
+await runToolingCli(process.argv.slice(2));

package/config-files.d.ts

@@ -0,0 +1,14 @@
+import type { ConfigName } from './types.js';
+export type ToolingConfigExtension = 'js' | 'ts';
+export type ToolingConfigFilesOptions = {
+    readonly extension?: ToolingConfigExtension;
+    readonly names?: readonly ConfigName[];
+    readonly storybookPreviewSpecifier?: 'extensionless' | 'js';
+    readonly storybookPreviewStyleImport?: string;
+    readonly storybookStories?: 'path' | 'relative';
+    readonly storybookMainContent?: string;
+    readonly storybookPreviewContent?: string;
+    readonly storybookPreviewPath?: string;
+};
+export type ToolingConfigFileMap = Record<string, string>;
+export declare const createToolingConfigFiles: (options?: ToolingConfigFilesOptions) => ToolingConfigFileMap;

package/config-files.js

@@ -0,0 +1,66 @@
+import { configTargets } from './config-targets.js';
+const extensionConfigPaths = new Set([
+    'eslint.config.js',
+    'jest.config.js',
+    'prettier.config.js',
+    'stylelint.config.js',
+]);
+const defaultToolingConfigNames = [
+    'typescript',
+    'eslint',
+    'prettier',
+    'jest',
+    'storybook',
+];
+const storybookPathMainContent = `import config from '@vyriy/storybook-config';
+import { path } from '@vyriy/path';
+
+export default {
+  ...config,
+  stories: [
+    path('**/*.mdx'),
+    path('**/*.stories.@(js|jsx|mjs|ts|tsx)'),
+  ],
+};
+`;
+const getStorybookPreviewContent = (specifier, styleImport) => {
+    const exportLine = specifier === 'extensionless'
+        ? "export { default } from '@vyriy/storybook-config/preview';\n"
+        : "export { default } from '@vyriy/storybook-config/preview.js';\n";
+    return styleImport ? `import '${styleImport}';\n\n${exportLine}` : exportLine;
+};
+const withExtension = (path, extension) => {
+    if (!extensionConfigPaths.has(path)) {
+        return path;
+    }
+    return path.replace(/\.js$/, `.${extension}`);
+};
+const withStorybookOverrides = (file, options) => {
+    if (file.path === '.storybook/main.ts') {
+        return {
+            ...file,
+            content: options.storybookMainContent ?? (options.storybookStories === 'path' ? storybookPathMainContent : file.content),
+        };
+    }
+    if (file.path === '.storybook/preview.ts') {
+        return {
+            ...file,
+            content: options.storybookPreviewContent ??
+                getStorybookPreviewContent(options.storybookPreviewSpecifier ?? 'js', options.storybookPreviewStyleImport),
+            path: options.storybookPreviewPath ?? file.path,
+        };
+    }
+    return file;
+};
+export const createToolingConfigFiles = (options = {}) => {
+    const extension = options.extension ?? 'js';
+    const names = options.names ?? defaultToolingConfigNames;
+    const files = {};
+    for (const name of names) {
+        for (const targetFile of configTargets[name].files) {
+            const file = withStorybookOverrides(targetFile, options);
+            files[withExtension(file.path, extension)] = file.content;
+        }
+    }
+    return files;
+};

package/config-targets.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigName, ConfigTarget } from './types.js';
+export declare const configTargets: Record<ConfigName, ConfigTarget>;
+export declare const defaultConfigNames: readonly ConfigName[];
+export declare const allConfigNames: ConfigName[];

package/config-targets.js

@@ -0,0 +1,84 @@
+const typescriptContent = `${JSON.stringify({
+    extends: '@vyriy/typescript-config/index.json',
+    include: [
+        '.bin/**/*.ts',
+        '.bin/**/*.tsx',
+        '.storybook/**/*.ts',
+        '.storybook/**/*.tsx',
+        'packages/**/*.ts',
+        'packages/**/*.tsx',
+        'workspaces/**/*.ts',
+        'workspaces/**/*.tsx',
+        '*.ts',
+        '*.tsx',
+    ],
+}, null, 2)}
+`;
+const eslintContent = `import config from '@vyriy/eslint-config';
+
+export default config;
+`;
+const prettierContent = `export { default } from '@vyriy/prettier-config';
+`;
+const jestContent = `export { default } from '@vyriy/jest-config';
+`;
+const stylelintContent = `export { default } from '@vyriy/stylelint-config';
+`;
+const storybookMainContent = `import config from '@vyriy/storybook-config';
+
+import type { StorybookConfig } from '@vyriy/storybook-config';
+
+const main: StorybookConfig = {
+  ...config,
+  stories: [
+    '../**/*.mdx',
+    '../**/*.stories.@(js|jsx|mjs|ts|tsx)',
+  ],
+};
+
+export default main;
+`;
+const storybookPreviewContent = `export { default } from '@vyriy/storybook-config/preview.js';
+`;
+export const configTargets = {
+    eslint: {
+        name: 'eslint',
+        packageName: '@vyriy/eslint-config',
+        files: [{ path: 'eslint.config.js', content: eslintContent }],
+    },
+    jest: {
+        name: 'jest',
+        packageName: '@vyriy/jest-config',
+        files: [{ path: 'jest.config.js', content: jestContent }],
+    },
+    prettier: {
+        name: 'prettier',
+        packageName: '@vyriy/prettier-config',
+        files: [{ path: 'prettier.config.js', content: prettierContent }],
+    },
+    storybook: {
+        name: 'storybook',
+        packageName: '@vyriy/storybook-config',
+        files: [
+            { path: '.storybook/main.ts', content: storybookMainContent },
+            { path: '.storybook/preview.ts', content: storybookPreviewContent },
+        ],
+    },
+    stylelint: {
+        name: 'stylelint',
+        packageName: '@vyriy/stylelint-config',
+        files: [{ path: 'stylelint.config.js', content: stylelintContent }],
+    },
+    typescript: {
+        name: 'typescript',
+        packageName: '@vyriy/typescript-config',
+        files: [{ path: 'tsconfig.json', content: typescriptContent }],
+    },
+};
+export const defaultConfigNames = [
+    'typescript',
+    'eslint',
+    'prettier',
+    'jest',
+];
+export const allConfigNames = Object.keys(configTargets);

package/file-exists.d.ts

@@ -0,0 +1 @@
+export declare const fileExists: (path: string) => Promise<boolean>;

package/file-exists.js

@@ -0,0 +1,13 @@
+import { access } from 'node:fs/promises';
+export const fileExists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+};

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './config-files.js';
+export * from './tooling.js';
+export * from './config-targets.js';
+export * from './parse-config-args.js';
+export type * from './types.js';

package/index.js

@@ -0,0 +1,4 @@
+export * from './config-files.js';
+export * from './tooling.js';
+export * from './config-targets.js';
+export * from './parse-config-args.js';

package/package-dependencies.d.ts

@@ -0,0 +1 @@
+export declare const findMissingPackages: (cwd: string, packageNames: readonly string[]) => Promise<string[]>;

package/package-dependencies.js

@@ -0,0 +1,28 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const dependencyFields = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+];
+const readPackageJson = async (cwd) => {
+    try {
+        return JSON.parse(await readFile(join(cwd, 'package.json'), 'utf8'));
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+};
+export const findMissingPackages = async (cwd, packageNames) => {
+    const packageJson = await readPackageJson(cwd);
+    if (!packageJson) {
+        return [...packageNames];
+    }
+    return packageNames.filter((packageName) => {
+        return !dependencyFields.some((field) => Boolean(packageJson[field]?.[packageName]));
+    });
+};

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "@vyriy/tooling",
+  "version": "0.8.2",
+  "description": "Vyriy tooling config generator CLI.",
+  "homepage": "https://vyriy.dev/docs/tooling/",
+  "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "packageManager": "yarn@4.16.0",
+  "bin": {
+    "vt": "./bin/index.js",
+    "vyriy-tooling": "./bin/index.js"
+  },
+  "agents": "./AGENTS.md",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/evheniy/vyriy",
+    "directory": "packages/tooling"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./config-files": {
+      "types": "./config-files.d.ts",
+      "import": "./config-files.js",
+      "default": "./config-files.js"
+    },
+    "./config-files.js": {
+      "types": "./config-files.d.ts",
+      "import": "./config-files.js",
+      "default": "./config-files.js"
+    },
+    "./config-targets": {
+      "types": "./config-targets.d.ts",
+      "import": "./config-targets.js",
+      "default": "./config-targets.js"
+    },
+    "./config-targets.js": {
+      "types": "./config-targets.d.ts",
+      "import": "./config-targets.js",
+      "default": "./config-targets.js"
+    },
+    "./file-exists": {
+      "types": "./file-exists.d.ts",
+      "import": "./file-exists.js",
+      "default": "./file-exists.js"
+    },
+    "./file-exists.js": {
+      "types": "./file-exists.d.ts",
+      "import": "./file-exists.js",
+      "default": "./file-exists.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./package-dependencies": {
+      "types": "./package-dependencies.d.ts",
+      "import": "./package-dependencies.js",
+      "default": "./package-dependencies.js"
+    },
+    "./package-dependencies.js": {
+      "types": "./package-dependencies.d.ts",
+      "import": "./package-dependencies.js",
+      "default": "./package-dependencies.js"
+    },
+    "./parse-config-args": {
+      "types": "./parse-config-args.d.ts",
+      "import": "./parse-config-args.js",
+      "default": "./parse-config-args.js"
+    },
+    "./parse-config-args.js": {
+      "types": "./parse-config-args.d.ts",
+      "import": "./parse-config-args.js",
+      "default": "./parse-config-args.js"
+    },
+    "./select-configs": {
+      "types": "./select-configs.d.ts",
+      "import": "./select-configs.js",
+      "default": "./select-configs.js"
+    },
+    "./select-configs.js": {
+      "types": "./select-configs.d.ts",
+      "import": "./select-configs.js",
+      "default": "./select-configs.js"
+    },
+    "./tooling": {
+      "types": "./tooling.d.ts",
+      "import": "./tooling.js",
+      "default": "./tooling.js"
+    },
+    "./tooling.js": {
+      "types": "./tooling.d.ts",
+      "import": "./tooling.js",
+      "default": "./tooling.js"
+    },
+    "./write-config-files": {
+      "types": "./write-config-files.d.ts",
+      "import": "./write-config-files.js",
+      "default": "./write-config-files.js"
+    },
+    "./write-config-files.js": {
+      "types": "./write-config-files.d.ts",
+      "import": "./write-config-files.js",
+      "default": "./write-config-files.js"
+    }
+  }
+}

package/parse-config-args.d.ts

@@ -0,0 +1,2 @@
+import type { ParseConfigArgs } from './types.js';
+export declare const parseConfigArgs: ParseConfigArgs;

package/parse-config-args.js

@@ -0,0 +1,49 @@
+import { allConfigNames, defaultConfigNames } from './config-targets.js';
+const isConfigName = (value) => {
+    return allConfigNames.includes(value);
+};
+export const parseConfigArgs = (args) => {
+    const dryRun = args.includes('--dry-run');
+    const force = args.includes('--force');
+    const help = args.includes('--help') || args.includes('-h');
+    const version = args.includes('--version') || args.includes('-v');
+    const type = args.find((arg) => !arg.startsWith('-')) ?? 'init';
+    if (help) {
+        return {
+            dryRun,
+            force,
+            names: [],
+            type: 'help',
+        };
+    }
+    if (version) {
+        return {
+            dryRun,
+            force,
+            names: [],
+            type: 'version',
+        };
+    }
+    if (type === 'init') {
+        return {
+            dryRun,
+            force,
+            names: defaultConfigNames,
+            type,
+        };
+    }
+    if (isConfigName(type)) {
+        return {
+            dryRun,
+            force,
+            names: [type],
+            type,
+        };
+    }
+    return {
+        dryRun,
+        force,
+        names: [],
+        type: 'unknown',
+    };
+};

package/select-configs.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigName } from './types.js';
+export declare const selectConfigs: () => Promise<readonly ConfigName[]>;

package/select-configs.js

@@ -0,0 +1,50 @@
+import { createInterface } from 'node:readline/promises';
+import { allConfigNames, defaultConfigNames } from './config-targets.js';
+const labels = {
+    eslint: 'ESLint',
+    jest: 'Jest',
+    prettier: 'Prettier',
+    storybook: 'Storybook',
+    stylelint: 'Stylelint',
+    typescript: 'TypeScript',
+};
+const parseAnswer = (answer) => {
+    const selected = new Set();
+    for (const token of answer
+        .split(',')
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean)) {
+        const index = Number(token);
+        const configName = allConfigNames[index - 1];
+        if (configName) {
+            selected.add(configName);
+            continue;
+        }
+        if (allConfigNames.includes(token)) {
+            selected.add(token);
+        }
+    }
+    return [...selected];
+};
+export const selectConfigs = async () => {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return defaultConfigNames;
+    }
+    console.log('Select configs to create. Press enter for defaults.');
+    allConfigNames.forEach((name, index) => {
+        const defaultMarker = defaultConfigNames.includes(name) ? ' default' : '';
+        console.log(`${index + 1}. ${labels[name]}${defaultMarker}`);
+    });
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question('Configs: ');
+        const selected = parseAnswer(answer);
+        return selected.length > 0 ? selected : defaultConfigNames;
+    }
+    finally {
+        readline.close();
+    }
+};

package/tooling.d.ts

@@ -0,0 +1,4 @@
+import type { RunToolingCli, ToolingHelpText } from './types.js';
+export declare const toolingVersion: string;
+export declare const createToolingHelpText: ToolingHelpText;
+export declare const runToolingCli: RunToolingCli;

package/tooling.js

@@ -0,0 +1,90 @@
+import { configTargets } from './config-targets.js';
+import { fileExists } from './file-exists.js';
+import { findMissingPackages } from './package-dependencies.js';
+import { parseConfigArgs } from './parse-config-args.js';
+import { selectConfigs } from './select-configs.js';
+import { writeConfigFiles } from './write-config-files.js';
+import packageJson from './package.json' with { type: 'json' };
+const unique = (values) => [...new Set(values)];
+export const toolingVersion = packageJson.version;
+export const createToolingHelpText = (command = 'vyriy-tooling', alias = 'vt') => {
+    const aliasText = alias ? `  ${alias} init                  Alias for ${command}\n` : '';
+    const aliasExampleText = alias ? `\n  ${alias} init\n  ${alias} typescript --dry-run` : '';
+    return `Vyriy Tooling
+
+Usage:
+  ${command} init
+  ${command} typescript
+  ${command} eslint
+  ${command} prettier
+  ${command} jest
+  ${command} storybook
+  ${command} stylelint
+${aliasText}\
+  ${command} --help, -h          Show tooling help
+  ${command} --version, -v       Show version
+
+Options:
+  --force                     Overwrite existing config files
+  --dry-run                   Print files that would be created without writing them
+
+Examples:
+  ${command} init
+  ${command} typescript
+  ${command} storybook --force
+  ${command} prettier --dry-run${aliasExampleText}`;
+};
+const collectFiles = (names) => {
+    return names.flatMap((name) => [...configTargets[name].files]);
+};
+const printMissingPackages = (missingPackages) => {
+    if (missingPackages.length === 0) {
+        return;
+    }
+    console.log('');
+    console.log('Missing Vyriy config packages:');
+    console.log('');
+    for (const packageName of missingPackages) {
+        console.log(`- ${packageName}`);
+    }
+    console.log('');
+    console.log('Install them with:');
+    console.log('');
+    console.log(`yarn add -D ${missingPackages.join(' ')}`);
+};
+export const runToolingCli = async (args = [], commandName = 'vyriy-tooling', alias = 'vt', cwd = process.cwd()) => {
+    const command = parseConfigArgs(args);
+    if (command.type === 'help') {
+        console.log(createToolingHelpText(commandName, alias));
+        process.exitCode = 0;
+        return;
+    }
+    if (command.type === 'version') {
+        console.log(toolingVersion);
+        process.exitCode = 0;
+        return;
+    }
+    if (command.type === 'unknown') {
+        console.error('Unknown tooling command.');
+        console.log(createToolingHelpText(commandName, alias));
+        process.exitCode = 1;
+        return;
+    }
+    const names = command.type === 'init' ? await selectConfigs() : command.names;
+    const files = collectFiles(names);
+    const writtenFiles = await writeConfigFiles({
+        cwd,
+        dryRun: command.dryRun,
+        exists: fileExists,
+        files,
+        force: command.force,
+    });
+    if (command.dryRun || writtenFiles.length === 0) {
+        process.exitCode = 0;
+        return;
+    }
+    const packageNames = unique(names.map((name) => configTargets[name].packageName));
+    const missingPackages = await findMissingPackages(cwd, packageNames);
+    printMissingPackages(missingPackages);
+    process.exitCode = 0;
+};

package/types.d.ts

@@ -0,0 +1,24 @@
+export type ConfigName = 'eslint' | 'jest' | 'prettier' | 'storybook' | 'stylelint' | 'typescript';
+export type ConfigCommand = {
+    readonly type: 'help' | 'version';
+    readonly dryRun: boolean;
+    readonly force: boolean;
+    readonly names: readonly ConfigName[];
+} | {
+    readonly dryRun: boolean;
+    readonly force: boolean;
+    readonly names: readonly ConfigName[];
+    readonly type: 'init' | ConfigName | 'unknown';
+};
+export type ConfigFile = {
+    readonly path: string;
+    readonly content: string;
+};
+export type ConfigTarget = {
+    readonly files: readonly ConfigFile[];
+    readonly name: ConfigName;
+    readonly packageName: string;
+};
+export type ToolingHelpText = (command?: string, alias?: false | string) => string;
+export type ParseConfigArgs = (args: readonly string[]) => ConfigCommand;
+export type RunToolingCli = (args?: readonly string[], command?: string, alias?: false | string, cwd?: string) => Promise<void>;

package/write-config-files.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigFile } from './types.js';
+type WriteConfigFilesOptions = {
+    readonly cwd: string;
+    readonly dryRun: boolean;
+    readonly exists: (path: string) => Promise<boolean>;
+    readonly files: readonly ConfigFile[];
+    readonly force: boolean;
+};
+export declare const writeConfigFiles: ({ cwd, dryRun, exists, files, force, }: WriteConfigFilesOptions) => Promise<readonly ConfigFile[]>;
+export {};

package/write-config-files.js

@@ -0,0 +1,29 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export const writeConfigFiles = async ({ cwd, dryRun, exists, files, force, }) => {
+    const writable = [];
+    for (const file of files) {
+        if (!force && (await exists(join(cwd, file.path)))) {
+            console.log(`Skipped ${file.path} because it already exists.`);
+            console.log('Use --force to overwrite it.');
+            continue;
+        }
+        writable.push(file);
+    }
+    if (dryRun) {
+        if (writable.length > 0) {
+            console.log('Would create:');
+            for (const file of writable) {
+                console.log(`- ${file.path}`);
+            }
+        }
+        return writable;
+    }
+    for (const file of writable) {
+        const path = join(cwd, file.path);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, file.content, 'utf8');
+        console.log(`${force ? 'Wrote' : 'Created'} ${file.path}.`);
+    }
+    return writable;
+};