@ceylar/ada 0.0.2

package/eslint.config.mjs

@@ -0,0 +1,67 @@
+import js from '@eslint/js';
+import react from 'eslint-plugin-react';
+import reactHooks from 'eslint-plugin-react-hooks';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import globals from 'globals';
+import ts from 'typescript-eslint';
+
+/** @type {import('eslint').Linter.Config<Linter.RulesRecord>[]} */
+export default ts.config(
+  js.configs.recommended,
+  ...ts.configs.recommended,
+  {
+    plugins: {
+      react: react,
+      'react-hooks': reactHooks,
+      'simple-import-sort': simpleImportSort,
+      ts: ts.plugin
+    },
+    rules: {
+      'prefer-const': 'error',
+      'no-else-return': 'error',
+
+      'react-hooks/exhaustive-deps': 'off',
+
+      'no-console': 'warn',
+
+      'simple-import-sort/exports': 'error',
+      'simple-import-sort/imports': [
+        'error',
+        {
+          groups: [
+            ['^react', '^@?\\w'],
+            ['^@(([\\/.]?\\w)|assets|test-utils)'],
+            ['^\\u0000'],
+            ['^\\.\\.(?!/?$)', '^\\.\\./?$'],
+            ['^\\./(?=.*/)(?!/?$)', '^\\.(?!/?$)', '^\\./?$'],
+            ['^.+\\.s?css$']
+          ]
+        }
+      ]
+    },
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.browser,
+        ...globals.es2022
+      }
+    }
+  },
+  {
+    languageOptions: {
+      parserOptions: {
+        project: ['tsconfig.json']
+      }
+    },
+    files: ['/src/**/*.ts', '/src/**/*.tsx']
+  },
+  {
+    languageOptions: {
+      parserOptions: react.configs.recommended.parserOptions
+    },
+    files: ['/src/**/*.js', '/src/**/*.jsx']
+  },
+  {
+    ignores: ['node_modules', 'build', 'dist']
+  }
+);

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@ceylar/ada",
+  "description": "CLI to help you initialize projects",
+  "version": "0.0.2",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ada": "dist/index.js"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && cross-env NODE_ENV=production rollup -c --bundleConfigAsCjs",
+    "dev": "shx rm -rf dist && cross-env NODE_ENV=development rollup -c --bundleConfigAsCjs --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "format": "prettier --check src --ignore-path .gitignore",
+    "format:fix": "prettier --write src --ignore-path .gitignore"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.9",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-react": "^7.26.3",
+    "@babel/preset-typescript": "^7.26.0",
+    "@eslint/js": "^9.21.0",
+    "@rollup/plugin-alias": "^5.1.1",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^22.13.4",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.21.0",
+    "eslint-plugin-react": "^7.37.4",
+    "eslint-plugin-react-hooks": "^5.1.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "globals": "^16.0.0",
+    "prettier": "^3.5.2",
+    "rollup": "^4.34.8",
+    "rollup-plugin-copy": "^3.5.0",
+    "shx": "^0.3.4",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.24.1"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "zod": "^3.24.2"
+  },
+  "repository": "https://github.com/Ceylar37/ada.git",
+  "author": "ceylar37 <ceylar37@gmail.com>"
+}

package/prettier.config.mjs

@@ -0,0 +1,12 @@
+/** @type {import('prettier').Config} */
+export default {
+  printWidth: 120,
+  singleQuote: true,
+  jsxSingleQuote: true,
+  trailingComma: 'none',
+  semi: true,
+  tabWidth: 2,
+  useTabs: false,
+  endOfLine: 'crlf',
+  arrowParens: 'always'
+};

package/readme.md

@@ -0,0 +1,3 @@
+### ada
+
+CLI to help you initialize your javascript projects

package/resources/eslint.config.mjs

@@ -0,0 +1,67 @@
+import js from '@eslint/js';
+import react from 'eslint-plugin-react';
+import reactHooks from 'eslint-plugin-react-hooks';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import globals from 'globals';
+import ts from 'typescript-eslint';
+
+/** @type {import('eslint').Linter.Config<Linter.RulesRecord>[]} */
+export default ts.config(
+  js.configs.recommended,
+  ...ts.configs.recommended,
+  {
+    plugins: {
+      react: react,
+      'react-hooks': reactHooks,
+      'simple-import-sort': simpleImportSort,
+      ts: ts.plugin
+    },
+    rules: {
+      'prefer-const': 'error',
+      'no-else-return': 'error',
+
+      'react-hooks/exhaustive-deps': 'off',
+
+      'no-console': 'warn',
+
+      'simple-import-sort/exports': 'error',
+      'simple-import-sort/imports': [
+        'error',
+        {
+          groups: [
+            ['^react', '^@?\\w'],
+            ['^@(([\\/.]?\\w)|assets|test-utils)'],
+            ['^\\u0000'],
+            ['^\\.\\.(?!/?$)', '^\\.\\./?$'],
+            ['^\\./(?=.*/)(?!/?$)', '^\\.(?!/?$)', '^\\./?$'],
+            ['^.+\\.s?css$']
+          ]
+        }
+      ]
+    },
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.browser,
+        ...globals.es2022
+      }
+    }
+  },
+  {
+    languageOptions: {
+      parserOptions: {
+        project: ['tsconfig.json']
+      }
+    },
+    files: ['/src/**/*.ts', '/src/**/*.tsx']
+  },
+  {
+    languageOptions: {
+      parserOptions: react.configs.recommended.parserOptions
+    },
+    files: ['/src/**/*.js', '/src/**/*.jsx']
+  },
+  {
+    ignores: ['node_modules', 'build', 'dist']
+  }
+);

package/resources/prettier.config.mjs

@@ -0,0 +1,12 @@
+/** @type {import('prettier').Config} */
+export default {
+  printWidth: 120,
+  singleQuote: true,
+  jsxSingleQuote: true,
+  trailingComma: 'none',
+  semi: true,
+  tabWidth: 2,
+  useTabs: false,
+  endOfLine: 'crlf',
+  arrowParens: 'always'
+};

package/resources/stylelint.config.mjs

@@ -0,0 +1,7 @@
+/** @type {import('stylelint').Config} */
+export default {
+  extends: 'stylelint-config-standard-scss',
+  rules: {
+    'selector-class-pattern': ['^[a-z][a-zA-Z0-9]*$', { message: 'Selector should be in camelCase' }]
+  }
+};

package/resources/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "newLine": "lf",
+    "moduleResolution": "bundler",
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "sourceMap": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+    }
+  },
+  "exclude": [
+    "dist",
+    "node_modules",
+  ]
+}

package/rollup.config.ts

@@ -0,0 +1,59 @@
+import alias from '@rollup/plugin-alias';
+import babel from '@rollup/plugin-babel';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import resolve from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+
+import packageJSON from './package.json';
+
+import { resolve as resolvePath } from 'path';
+import copy from 'rollup-plugin-copy';
+
+const sourcemap = false;
+const input = 'src/index.ts';
+const banner = `/* @license ${packageJSON.name} v${packageJSON.version} */`;
+
+const isDev = process.env.NODE_ENV === 'development';
+
+/** @type {import('rollup').RollupOptions[]} */
+export default [
+  {
+    input,
+    output: Object.values(packageJSON.bin).map((bin) => ({
+      format: 'esm',
+      file: bin,
+      sourcemap,
+      banner
+    })),
+    plugins: [
+      alias({
+        entries: [{ find: '@', replacement: resolvePath(__dirname, './src') }]
+      }),
+      resolve({
+        extensions: ['.js', '.ts']
+      }),
+      commonjs({
+        include: /node_modules/,
+        ignoreDynamicRequires: true
+      }),
+      typescript({
+        tsconfig: './tsconfig.json',
+        compilerOptions: { noCheck: isDev },
+        noForceEmit: true
+      }),
+      babel({
+        exclude: /node_modules/,
+        extensions: ['.js', '.ts'],
+        babelHelpers: 'bundled',
+        presets: ['@babel/preset-env', '@babel/preset-typescript']
+      }),
+      json(),
+      copy({
+        targets: [{ src: 'resources/*', dest: 'dist/resources' }]
+      }),
+      ...(!isDev ? [terser()] : [])
+    ]
+  }
+];

package/src/cli/commands/get.ts

@@ -0,0 +1,21 @@
+import { get as getConfig } from '@/config';
+import { selectConfigSchema } from '@/config/schema';
+import { isEmpty } from '@/util';
+
+import { AppCommand } from '../type';
+
+const get: AppCommand<typeof selectConfigSchema> = {
+  name: 'get',
+  description: 'get variables from config',
+  options: [['-m, --manager', 'package manager that will be used to install dependencies']],
+  schema: selectConfigSchema,
+  action: (options) => {
+    if (isEmpty(options)) {
+      console.log(getConfig());
+      return;
+    }
+    console.log(getConfig(options));
+  }
+};
+
+export { get };

package/src/cli/commands/index.ts

@@ -0,0 +1,3 @@
+export { get } from './get';
+export { init } from './init';
+export { set } from './set';

package/src/cli/commands/init.ts

@@ -0,0 +1,102 @@
+import { get } from '@/config';
+import { Manager, managerSchema } from '@/entities/manager';
+import { logger, resolveCurrentDir } from '@/util';
+
+import { AppCommand } from '../type';
+
+import { exec } from 'child_process';
+import fsPromises from 'fs/promises';
+import { z } from 'zod';
+
+const initSchema = z.object({
+  prettier: z.boolean().optional(),
+  eslint: z.boolean().optional(),
+  typescript: z.boolean().optional(),
+  stylelint: z.boolean().optional(),
+  manager: managerSchema.optional()
+});
+
+const getInstallationString = (manager: Manager, packages: string[]) => {
+  switch (manager) {
+    case 'npm':
+      return `npm install --save-dev ${packages.join(' ')}`;
+    case 'yarn':
+      return `yarn add --dev ${packages.join(' ')}`;
+    case 'pnpm':
+      return `pnpm add --save-dev ${packages.join(' ')}`;
+  }
+};
+
+const installDependencies = (manager: Manager, packages: string[]) => {
+  const childProcess = exec(getInstallationString(manager, packages));
+  childProcess.stdout?.pipe(process.stdout);
+  childProcess.stderr?.pipe(process.stderr);
+};
+
+const copyResource = async (resource: string) => {
+  await fsPromises.copyFile(resolveCurrentDir('resources', resource), resource);
+};
+
+type Init = z.infer<typeof initSchema>;
+const setupFunctionsDictionary: Record<Exclude<keyof Init, 'manager'>, (manager: Manager) => void> = {
+  prettier: async (manager) => {
+    await copyResource('prettier.config.mjs');
+    installDependencies(manager, ['prettier']);
+  },
+  eslint: async (manager) => {
+    await copyResource('eslint.config.mjs');
+    installDependencies(manager, [
+      'eslint',
+      '@eslint/js',
+      'eslint-plugin-react',
+      'eslint-plugin-react-hooks',
+      'eslint-plugin-simple-import-sort',
+      'globals',
+      'typescript-eslint'
+    ]);
+  },
+  typescript: async (manager) => {
+    await copyResource('tsconfig.json');
+    installDependencies(manager, ['typescript']);
+  },
+  stylelint: async (manager) => {
+    await copyResource('stylelint.config.mjs');
+    installDependencies(manager, ['stylelint', 'stylelint-config-standard-scss']);
+  }
+};
+
+const init: AppCommand<typeof initSchema> = {
+  name: 'init',
+  description: 'initialize configs',
+  options: [
+    ['-p, --prettier', 'setup prettier'],
+    ['-e, --eslint', 'setup eslint'],
+    ['-t, --typescript', 'setup typescript'],
+    ['-s, --stylelint', 'setup stylelint'],
+    ['-m, --manager <npm | yarn | pnpm>', 'package manager that will be used to install dependencies']
+  ],
+  schema: initSchema,
+  isDefault: true,
+  action: (options) => {
+    const optionsWithConfig = {
+      ...get(),
+      ...options
+    };
+
+    const { manager, ...rest } = optionsWithConfig;
+
+    if (!manager) {
+      return logger.error(
+        "Manager didn't specified. Please, set it up with `set` command or use -m or --manager option."
+      );
+    }
+
+    Object.entries(rest).forEach(([key, value]) => {
+      if (value) {
+        setupFunctionsDictionary[key as keyof typeof rest](manager);
+      }
+    });
+  }
+};
+
+export { init };

package/src/cli/commands/set.ts

@@ -0,0 +1,13 @@
+import { configSchema, set as setConfig } from '@/config';
+
+import { AppCommand } from '../type';
+
+const set: AppCommand<typeof configSchema> = {
+  name: 'set',
+  description: 'sets variable to config',
+  options: [['-m, --manager <npm | yarn | pnpm>', 'package manager that will be used to install dependencies']],
+  schema: configSchema,
+  action: setConfig
+};
+
+export { set };

package/src/cli/type.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+interface AppCommand<Schema extends z.ZodType> {
+  name: string;
+  description: string;
+  options?: [string, string?][];
+  action: (options: z.infer<Schema>) => void;
+  schema: Schema;
+  isDefault?: true;
+}
+
+export type { AppCommand };

package/src/cli/util.ts

@@ -0,0 +1,23 @@
+import { ZodError } from 'zod';
+
+const getOptionKeys = (option: [string, string?]) => {
+  const short = option[0].match(/(?<!-)-(\w)/)?.[1];
+  const long = option[0].match(/--(\w+)/)?.[1];
+
+  return { short, long };
+};
+
+const parseCliError = (error: ZodError, argv: string[], declaredOptions: [string, string?][]) => {
+  const option = declaredOptions.map(getOptionKeys).find(({ long, short }) => {
+    return long ? error.errors[0].path[0] === long : error.errors[0].path[0] === short;
+  });
+
+  if (option) {
+    const { short, long } = option;
+    const errorOption = argv.findLast((arg) => arg === `-${short}` || arg === `--${long}`);
+
+    return `Error in option "${errorOption}". ${error.errors[0].message}`;
+  }
+};
+
+export { parseCliError };

package/src/config/get.ts

@@ -0,0 +1,38 @@
+import { resolveCurrentDir } from '@/util';
+
+import { Config, SelectConfig } from './type';
+
+import fs from 'fs';
+
+interface Get {
+  (): Config;
+  <T extends SelectConfig>(configSelect: SelectConfig): Pick<Config, T extends SelectConfig ? keyof T : never>;
+  <T extends keyof Config>(key: T): Config[T];
+}
+
+const get = ((key: keyof Config | SelectConfig | undefined) => {
+  const configPath = resolveCurrentDir('config.json');
+  const exists = fs.existsSync(configPath);
+
+  if (!exists) {
+    return {} as Config;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8')) as Config;
+
+  if (key && typeof key === 'object') {
+    return Object.fromEntries(
+      Object.entries(key)
+        .filter(([key]) => config[key as keyof SelectConfig] !== undefined)
+        .map(([key]) => [key, config[key as keyof SelectConfig]] as const)
+    ) as Pick<Config, keyof SelectConfig>;
+  }
+
+  if (key) {
+    return config[key];
+  }
+
+  return config;
+}) as Get;
+
+export { get };

package/src/config/index.ts

@@ -0,0 +1,4 @@
+export { get } from './get';
+export { configSchema, selectConfigSchema as keysConfigSchema } from './schema';
+export { set } from './set';
+export { type Config } from './type';

package/src/config/schema.ts

@@ -0,0 +1,19 @@
+import { managerSchema } from '@/entities/manager';
+
+import { z } from 'zod';
+
+const configShape = {
+  manager: managerSchema.optional()
+};
+const configSchema = z.object(configShape);
+
+type ToSelectConfigType<T> = {
+  [K in keyof T]: z.ZodOptional<z.ZodBoolean>;
+};
+const selectConfigSchema = z.object(
+  Object.fromEntries(configSchema.keyof().options.map((key) => [key, z.boolean().optional()])) as ToSelectConfigType<
+    typeof configShape
+  >
+);
+
+export { configSchema, selectConfigSchema };

package/src/config/set.ts

@@ -0,0 +1,14 @@
+import { resolveCurrentDir } from '@/util';
+
+import { get } from './get';
+import { Config } from './type';
+
+import fs from 'fs';
+
+const set = (newConfigData: Config) => {
+  const configPath = resolveCurrentDir('config.json');
+  const config = get();
+  fs.writeFileSync(configPath, JSON.stringify({ ...config, ...newConfigData }));
+};
+
+export { set };

package/src/config/type.ts

@@ -0,0 +1,8 @@
+import { configSchema, selectConfigSchema } from './schema';
+
+import { z } from 'zod';
+
+type Config = z.infer<typeof configSchema>;
+type SelectConfig = z.infer<typeof selectConfigSchema>;
+
+export type { Config, SelectConfig };

package/src/entities/manager/index.ts

@@ -0,0 +1,2 @@
+export { managerSchema } from './schema';
+export type { Manager } from './type';

package/src/entities/manager/schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+const managerSchema = z.enum(['npm', 'yarn', 'pnpm']);
+
+export { managerSchema };

package/src/entities/manager/type.ts

@@ -0,0 +1,7 @@
+import { managerSchema } from './schema';
+
+import { z } from 'zod';
+
+type Manager = z.infer<typeof managerSchema>;
+
+export type { Manager };

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import * as commands from '@/cli/commands';
+import { parseCliError } from '@/cli/util';
+import { logger } from '@/util';
+
+import packageJSON from '../package.json';
+
+import { program } from 'commander';
+
+program.name('ada');
+program.version(packageJSON.version);
+
+Object.values(commands).map((command) => {
+  const currentCommand = program.command(command.name, { isDefault: command.isDefault });
+
+  currentCommand.description(command.description);
+
+  command.options?.forEach((option) => {
+    currentCommand.option(option[0], option[1]);
+  });
+
+  currentCommand.action((options) => {
+    const { success, data, error } = command.schema.safeParse(options);
+    if (success) {
+      // @ts-expect-error: type inference
+      command.action(data);
+    } else {
+      logger.error(`${parseCliError(error, process.argv, command.options || [])}`);
+    }
+  });
+});
+
+// program
+//   .command('init', { isDefault: true })
+//   .description('initialize configs')
+//   .option('-p, --prettier', 'setup prettier')
+//   .option('-e, --eslint', 'setup eslint')
+//   .action((options) => {
+//     console.log('init', options);
+//   });
+
+// program
+//   .command('set')
+//   .description('sets variable to config')
+//   .option('-m, --manager <npm | yarn | pnpm>', 'package manager that will be used to install dependencies')
+//   .action((options) => {
+//     console.log('set', options);
+//   });
+
+program.parse(process.argv);

package/src/util/index.ts

@@ -0,0 +1,3 @@
+export { isEmpty } from './isEmpty';
+export { logger } from './logger';
+export { resolveCurrentDir } from './resolveCurrentDir';

package/src/util/isEmpty.ts

@@ -0,0 +1,11 @@
+const isEmpty = (obj: object) => {
+  for (const prop in obj) {
+    if (Object.hasOwn(obj, prop)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export { isEmpty };

package/src/util/logger.ts

@@ -0,0 +1,15 @@
+const logger = {
+  info(message: string) {
+    console.log(`\x1b[32m${message}\x1b[0m`);
+  },
+
+  warn(message: string) {
+    console.log(`\x1b[33m${message}\x1b[0m`);
+  },
+
+  error(message: string) {
+    console.log(`\x1b[31m${message}\x1b[0m`);
+  }
+};
+
+export { logger };

package/src/util/resolveCurrentDir.ts

@@ -0,0 +1,7 @@
+import { resolve } from 'path';
+
+const resolveCurrentDir = (...paths: string[]) => {
+  return resolve(import.meta.dirname, ...paths);
+};
+
+export { resolveCurrentDir };

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "ES2023",
+      "dom"
+    ],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}