@rtorcato/js-tooling 1.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Richard Torcato
+
+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,129 @@
+# js-tooling
+
+A comprehensive collection of JavaScript/TypeScript development tools and configurations for modern projects.
+
+## Installation
+
+Install the package globally or use it directly with npx:
+
+```bash
+
+# Or use with npx
+npx @rtorcato/js-tooling setup
+```
+
+## Getting started
+
+Use the interactive CLI to set up tooling for your project:
+
+```bash
+npx @rtorcato/js-tooling setup
+```
+
+Or import specific configurations:
+
+```javascript
+import '@rtorcato/js-tooling/typescript/base';
+```
+
+## Available Tools
+
+This package includes configurations and presets for:
+
+- **TypeScript** - Base configurations for different project types
+- **ESLint** - Linting rules for JavaScript and TypeScript
+- **Prettier** - Code formatting configuration
+- **Biome** - Fast linter and formatter
+- **Vitest** - Testing framework configuration
+- **Jest** - Testing framework presets
+- **Commitlint** - Commit message linting
+- **Semantic Release** - Automated versioning and publishing
+- **GitHub Actions** - CI/CD workflow templates
+- **And more...**
+
+## CI/CD Setup
+
+The package includes GitHub Actions workflows and semantic-release configuration. For automated publishing, set these secrets in your GitHub repository:
+
+1. **`NPM_TOKEN`** - npm authentication token for publishing packages
+2. **`GITHUB_TOKEN`** - automatically provided by GitHub Actions
+
+Repository settings: `https://github.com/your-username/your-repo/settings/secrets/actions`
+
+## CLI Commands
+
+The package provides several CLI commands:
+
+```bash
+# Interactive project setup wizard
+npx @rtorcato/js-tooling setup
+
+# Run commit message helper
+npx @rtorcato/js-tooling commitmessage
+
+# Hello world example
+npx @rtorcato/js-tooling helloworld
+```
+
+## Using with Package Managers
+
+### With pnpm
+```bash
+# Temporarily install and run
+pnpm --package=@rtorcato/js-tooling dlx setup
+
+# Or install globally
+pnpm add -g @rtorcato/js-tooling
+```
+
+### With npm
+```bash
+# Use directly
+npx @rtorcato/js-tooling setup
+
+# Or install globally  
+npm install -g @rtorcato/js-tooling
+```
+
+## Development
+
+To work on this package locally:
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/rtorcato/js-tooling.git
+   cd js-tooling
+   ```
+
+2. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+
+3. Build the CLI:
+   ```bash
+   pnpm run build-cli
+   ```
+
+4. Link globally for testing:
+   ```bash
+   pnpm link --global
+   ```
+
+For more details, refer to the [pnpm link documentation](https://pnpm.io/cli/link).
+
+## Status
+
+[![CI](https://github.com/rtorcato/js-tooling/actions/workflows/ci.yml/badge.svg)](https://github.com/rtorcato/js-tooling/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/@rtorcato%2Fjs-tooling.svg)](https://badge.fury.io/js/@rtorcato%2Fjs-tooling)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/rtorcato/js-tooling)](https://github.com/rtorcato/js-tooling/releases)
+[![GitHub issues](https://img.shields.io/github/issues/rtorcato/js-tooling)](https://github.com/rtorcato/js-tooling/issues)
+
+## Contributing
+
+Contributions are welcome! Please read our [contributing guidelines](CONTRIBUTING.md) and feel free to submit issues and pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/cli/commands/setup.js

@@ -0,0 +1,218 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+import path from 'node:path';
+import { generateConfigs } from '../generators/index.js';
+import { installDependencies } from '../utils/install.js';
+export async function setupProject(options) {
+    const targetDir = path.resolve(options.directory);
+    console.log(chalk.cyan('\n🛠️  Welcome to JS Tooling Setup!\n'));
+    console.log(chalk.gray(`Setting up tooling in: ${targetDir}\n`));
+    try {
+        // Check if directory exists and is writable
+        await fs.ensureDir(targetDir);
+        const config = await promptForConfig();
+        console.log(chalk.cyan('\n📝 Generating configuration files...\n'));
+        await generateConfigs(config, targetDir);
+        if (!options.skipInstall) {
+            console.log(chalk.cyan('\n📦 Installing dependencies...\n'));
+            await installDependencies(config, targetDir);
+        }
+        console.log(chalk.green('\n✅ Setup completed successfully!\n'));
+        // Show next steps
+        showNextSteps(config, targetDir);
+    }
+    catch (error) {
+        console.error(chalk.red('\n❌ Setup failed:'), error);
+        process.exit(1);
+    }
+}
+async function promptForConfig() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: '📦 What is your project name?',
+            default: path.basename(process.cwd()),
+            validate: (input) => input.trim().length > 0 || 'Project name is required',
+        },
+        {
+            type: 'list',
+            name: 'projectType',
+            message: '🏗️  What type of project are you building?',
+            choices: [
+                { name: '📚 Library/Package', value: 'library' },
+                { name: '🌐 Web Application', value: 'web-app' },
+                { name: '🚀 Node.js API', value: 'node-api' },
+                { name: '⚡ Next.js App', value: 'nextjs-app' },
+                { name: '⚛️  React App', value: 'react-app' },
+            ],
+        },
+        {
+            type: 'confirm',
+            name: 'useTypeScript',
+            message: '📘 Do you want to use TypeScript?',
+            default: true,
+        },
+        {
+            type: 'list',
+            name: 'tsConfig',
+            message: '⚙️  Which TypeScript configuration?',
+            choices: (answers) => {
+                const baseChoices = [
+                    { name: '🔧 Base (General purpose)', value: 'base' },
+                    { name: '🖥️  Node.js', value: 'node' },
+                ];
+                if (answers.projectType === 'nextjs-app') {
+                    return [{ name: '⚡ Next.js', value: 'next' }, ...baseChoices];
+                }
+                if (answers.projectType === 'react-app' || answers.projectType === 'web-app') {
+                    return [{ name: '⚛️  React', value: 'react' }, ...baseChoices];
+                }
+                if (answers.projectType === 'node-api') {
+                    return [
+                        { name: '🚀 Express/API', value: 'express' },
+                        { name: '🖥️  Node.js', value: 'node' },
+                    ];
+                }
+                return baseChoices;
+            },
+            when: (answers) => answers.useTypeScript,
+        },
+        {
+            type: 'list',
+            name: 'lintingTool',
+            message: '🔍 Which linting/formatting tool?',
+            choices: [
+                { name: '⚡ Biome (Fast, all-in-one)', value: 'biome' },
+                { name: '🔧 ESLint (Configurable)', value: 'eslint' },
+                { name: '🔥 Both Biome + ESLint', value: 'both' },
+                { name: '❌ None', value: 'none' },
+            ],
+            default: 'biome',
+        },
+        {
+            type: 'list',
+            name: 'eslintConfig',
+            message: '🔧 Which ESLint configuration?',
+            choices: (answers) => {
+                const choices = [{ name: '🔧 Base configuration', value: 'base' }];
+                if (answers.projectType === 'nextjs-app') {
+                    choices.unshift({ name: '⚡ Next.js configuration', value: 'nextjs' });
+                }
+                return choices;
+            },
+            when: (answers) => answers.lintingTool === 'eslint' || answers.lintingTool === 'both',
+        },
+        {
+            type: 'list',
+            name: 'testingFramework',
+            message: '🧪 Which testing framework?',
+            choices: [
+                { name: '⚡ Vitest (Fast, Vite-powered)', value: 'vitest' },
+                { name: '🃏 Jest (Traditional)', value: 'jest' },
+                { name: '🎭 Playwright (E2E)', value: 'playwright' },
+                { name: '❌ None', value: 'none' },
+            ],
+            default: 'vitest',
+        },
+        {
+            type: 'list',
+            name: 'testEnvironment',
+            message: '🌍 Test environment?',
+            choices: [
+                { name: '🖥️  Node.js', value: 'node' },
+                { name: '🌐 Browser (DOM)', value: 'browser' },
+                { name: '🔄 Both', value: 'both' },
+            ],
+            when: (answers) => answers.testingFramework === 'jest',
+            default: 'node',
+        },
+        {
+            type: 'confirm',
+            name: 'gitHooks',
+            message: '🪝 Set up Git hooks (Husky + lint-staged)?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'commitLint',
+            message: '📝 Set up conventional commit linting?',
+            default: true,
+            when: (answers) => answers.gitHooks,
+        },
+        {
+            type: 'confirm',
+            name: 'semanticRelease',
+            message: '🚀 Set up semantic release for automated versioning?',
+            default: (answers) => answers.projectType === 'library',
+            when: (answers) => answers.projectType === 'library',
+        },
+        {
+            type: 'list',
+            name: 'bundler',
+            message: '📦 Which bundler/build tool?',
+            choices: (answers) => {
+                const choices = [
+                    { name: '📦 tsup (TypeScript packages)', value: 'tsup' },
+                    { name: '⚡ esbuild (Fast bundling)', value: 'esbuild' },
+                    { name: '❌ None', value: 'none' },
+                ];
+                if (answers.projectType === 'web-app' || answers.projectType === 'react-app') {
+                    choices.unshift({ name: '⚡ Vite (Modern web apps)', value: 'vite' });
+                }
+                return choices;
+            },
+            when: (answers) => answers.projectType !== 'nextjs-app', // Next.js has its own bundler
+        },
+    ]);
+    return {
+        projectName: answers.projectName,
+        projectType: answers.projectType,
+        typescript: {
+            enabled: answers.useTypeScript || false,
+            config: answers.tsConfig || 'base',
+        },
+        linting: {
+            tool: answers.lintingTool || 'none',
+            eslintConfig: answers.eslintConfig,
+        },
+        formatting: {
+            tool: answers.lintingTool === 'biome' || answers.lintingTool === 'both'
+                ? 'biome'
+                : answers.lintingTool === 'eslint'
+                    ? 'prettier'
+                    : 'none',
+        },
+        testing: {
+            framework: answers.testingFramework || 'none',
+            environment: answers.testEnvironment,
+        },
+        gitHooks: answers.gitHooks || false,
+        commitLint: answers.commitLint || false,
+        semanticRelease: answers.semanticRelease || false,
+        bundler: answers.bundler || 'none',
+    };
+}
+function showNextSteps(config, _targetDir) {
+    console.log(chalk.bold('\n📋 Next Steps:\n'));
+    const steps = [];
+    if (config.typescript.enabled) {
+        steps.push('🔧 Customize your tsconfig.json as needed');
+    }
+    if (config.linting.tool !== 'none') {
+        steps.push(`🔍 Run linting with: ${config.linting.tool === 'biome' ? 'pnpm biome check .' : 'pnpm eslint .'}`);
+    }
+    if (config.testing.framework !== 'none') {
+        steps.push(`🧪 Run tests with: pnpm ${config.testing.framework}`);
+    }
+    if (config.gitHooks) {
+        steps.push('🪝 Commit your changes to test the git hooks');
+    }
+    steps.push('📖 Check the generated README.md for more details');
+    steps.forEach((step, index) => {
+        console.log(`  ${index + 1}. ${step}`);
+    });
+    console.log(chalk.dim('\n💡 All configuration files have been generated in your project directory.'));
+    console.log(chalk.dim('   You can modify them to suit your specific needs.\n'));
+}

package/dist/cli/generators/build.js

@@ -0,0 +1,90 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+export async function generateBuildConfigs(config, targetDir) {
+    if (config.bundler === 'tsup') {
+        await generateTsupConfig(targetDir);
+    }
+    else if (config.bundler === 'esbuild') {
+        await generateEsbuildConfig(targetDir);
+    }
+    else if (config.bundler === 'vite') {
+        await generateViteConfig(config, targetDir);
+    }
+    // Generate semantic-release config for GitHub
+    if (config.semanticRelease) {
+        await generateSemanticReleaseConfig(targetDir);
+    }
+}
+async function generateTsupConfig(targetDir) {
+    const tsupConfigPath = path.join(targetDir, 'tsup.config.ts');
+    const tsupConfig = `import { getConfig } from '@rtorcato/js-tooling/tsup'
+
+export default getConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  splitting: false,
+  sourcemap: true,
+}, process.env.NODE_ENV || 'development')
+`;
+    await fs.writeFile(tsupConfigPath, tsupConfig);
+}
+async function generateEsbuildConfig(targetDir) {
+    const esbuildConfigPath = path.join(targetDir, 'build.mjs');
+    const esbuildConfig = `import { build } from 'esbuild'
+import { nodeExternalsPlugin } from 'esbuild-node-externals'
+
+const isProduction = process.env.NODE_ENV === 'production'
+
+await build({
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  outdir: 'dist',
+  format: 'esm',
+  target: 'node18',
+  platform: 'node',
+  minify: isProduction,
+  sourcemap: !isProduction,
+  plugins: [nodeExternalsPlugin()],
+})
+
+console.log('Build completed!')
+`;
+    await fs.writeFile(esbuildConfigPath, esbuildConfig);
+}
+async function generateViteConfig(config, targetDir) {
+    const viteConfigPath = path.join(targetDir, 'vite.config.ts');
+    let viteConfig = `import { defineConfig } from 'vite'
+`;
+    if (config.projectType === 'react-app') {
+        viteConfig += `import react from '@vitejs/plugin-react'
+`;
+    }
+    viteConfig += `
+export default defineConfig({
+  plugins: [${config.projectType === 'react-app' ? 'react()' : ''}],
+  resolve: {
+    alias: {
+      '@': '/src',
+      '~': '/src'
+    }
+  },
+  build: {
+    outDir: 'dist',
+    sourcemap: true,
+  },
+  server: {
+    port: 3000,
+    open: true
+  }
+})
+`;
+    await fs.writeFile(viteConfigPath, viteConfig);
+}
+async function generateSemanticReleaseConfig(targetDir) {
+    const releaseConfigPath = path.join(targetDir, 'release.config.mjs');
+    const releaseConfig = `export { default } from '@rtorcato/js-tooling/semantic-release/github'
+`;
+    await fs.writeFile(releaseConfigPath, releaseConfig);
+}

package/dist/cli/generators/git.js

@@ -0,0 +1,133 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+export async function generateGitConfigs(config, targetDir) {
+    if (config.gitHooks) {
+        await generateHuskyConfig(config, targetDir);
+    }
+    if (config.commitLint) {
+        await generateCommitlintConfig(targetDir);
+    }
+    // Generate .gitignore
+    await generateGitignore(config, targetDir);
+}
+async function generateHuskyConfig(config, targetDir) {
+    const huskyDir = path.join(targetDir, '.husky');
+    await fs.ensureDir(huskyDir);
+    // Pre-commit hook
+    const preCommitPath = path.join(huskyDir, 'pre-commit');
+    const preCommitContent = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged
+`;
+    await fs.writeFile(preCommitPath, preCommitContent);
+    await fs.chmod(preCommitPath, 0o755);
+    // Commit-msg hook (if commitlint is enabled)
+    if (config.commitLint) {
+        const commitMsgPath = path.join(huskyDir, 'commit-msg');
+        const commitMsgContent = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit $1
+`;
+        await fs.writeFile(commitMsgPath, commitMsgContent);
+        await fs.chmod(commitMsgPath, 0o755);
+    }
+    // lint-staged configuration in package.json
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    const packageJson = await fs.readJson(packageJsonPath);
+    packageJson['lint-staged'] = {
+        '*.{js,ts,jsx,tsx}': [
+            config.linting.tool === 'biome' || config.linting.tool === 'both'
+                ? 'biome check --fix'
+                : 'eslint --fix',
+            'git add',
+        ],
+        '*.{json,md,yml,yaml}': [
+            config.linting.tool === 'biome' || config.linting.tool === 'both'
+                ? 'biome format --write'
+                : 'prettier --write',
+            'git add',
+        ],
+    };
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+async function generateCommitlintConfig(targetDir) {
+    const commitlintConfigPath = path.join(targetDir, 'commitlint.config.mjs');
+    const commitlintConfig = `export { default } from '@rtorcato/js-tooling/commitlint/config'
+`;
+    await fs.writeFile(commitlintConfigPath, commitlintConfig);
+}
+async function generateGitignore(config, targetDir) {
+    const gitignorePath = path.join(targetDir, '.gitignore');
+    let gitignoreContent = `# Dependencies
+node_modules/
+.pnpm-store
+
+# Build outputs
+dist/
+build/
+out/
+
+# Environment files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+*.lcov
+
+# TypeScript
+*.tsbuildinfo
+`;
+    // Add framework-specific ignores
+    if (config.projectType === 'nextjs-app') {
+        gitignoreContent += `
+# Next.js
+.next/
+.vercel
+`;
+    }
+    if (config.bundler === 'vite') {
+        gitignoreContent += `
+# Vite
+.vite/
+`;
+    }
+    if (config.testing.framework === 'playwright') {
+        gitignoreContent += `
+# Playwright
+/test-results/
+/playwright-report/
+/playwright/.cache/
+`;
+    }
+    await fs.writeFile(gitignorePath, gitignoreContent);
+}