@dmitryrechkin/eslint-standard 1.1.1 → 1.1.3

package/eslint.config.mjs

@@ -6,8 +6,8 @@ import stylisticPlugin from '@stylistic/eslint-plugin';
 import jsdocPlugin from 'eslint-plugin-jsdoc';
 import simpleImportSortPlugin from 'eslint-plugin-simple-import-sort';
 import perfectionistPlugin from 'eslint-plugin-perfectionist';
-import jsdocIndentPlugin from './eslint-plugin-jsdoc-indent.mjs';
-import interfaceBracePlugin from './eslint-plugin-interface-brace.mjs';
+import jsdocIndentPlugin from './src/plugins/jsdoc-indent.mjs';
+import interfaceBracePlugin from './src/plugins/interface-brace.mjs';
 
 export default function ({
 	tsconfigPath = './tsconfig.json',

package/package.json

@@ -1,19 +1,24 @@
 {
 	"name": "@dmitryrechkin/eslint-standard",
 	"description": "This package provides a shared ESLint configuration which includes TypeScript support and a set of specific linting rules designed to ensure high-quality and consistent code style across projects.",
-	"version": "1.1.1",
+	"version": "1.1.3",
 	"main": "eslint.config.mjs",
+	"bin": {
+	  "eslint-standard": "./src/cli/index.mjs"
+	},
 	"files": [
 	  "eslint.config.mjs",
-	  "eslint-plugin-jsdoc-indent.mjs",
+	  "src/",
 	  "README.md",
 	  "LICENSE"
 	],
 	"scripts": {
-	  "postinstall": "echo 'Remember to install peer dependencies:\n npm install eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-unused-imports @stylistic/eslint-plugin eslint-plugin-jsdoc --save-dev\n bun add eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-unused-imports @stylistic/eslint-plugin eslint-plugin-jsdoc --dev'",
+	  "postinstall": "node src/cli/postinstall.mjs",
 	  "package:publish": "npm publish --access public",
-	  "test": "npm run test:formatting",
-	  "test:formatting": "node tests/test-runner.js"
+	  "test": "npm run test:formatting && npm run test:cli",
+	  "test:formatting": "node tests/test-runner.js",
+	  "test:cli": "node tests/test-cli.js",
+	  "test:install": "node tests/test-install-simulation.js"
 	},
 	"keywords": [],
 	"author": "",

package/src/cli/check-deps.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Check for --install flag
+const shouldInstall = process.argv.includes('--install');
+
+// Get peer dependencies
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const peerDeps = packageJson.peerDependencies || {};
+
+// Check if running from node_modules and find project root
+const isInNodeModules = __dirname.includes('node_modules');
+let projectRoot;
+
+if (isInNodeModules) {
+	// Handle different package manager structures
+	// pnpm: .pnpm/@org+pkg@version_deps/node_modules/@org/pkg
+	// npm/yarn: node_modules/@org/pkg
+	const parts = __dirname.split('node_modules');
+	projectRoot = parts[0].replace(/[\\/]$/, ''); // Remove trailing slash
+} else {
+	projectRoot = process.cwd();
+}
+
+// Read project's package.json
+let projectPackageJson;
+try {
+	projectPackageJson = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf8'));
+} catch (error) {
+	console.error('❌ Could not read project package.json');
+	process.exit(1);
+}
+
+const allDeps = {
+	...projectPackageJson.dependencies || {},
+	...projectPackageJson.devDependencies || {}
+};
+
+console.log('🔍 Checking ESLint Standard peer dependencies...\n');
+
+let missingDeps = [];
+let outdatedDeps = [];
+
+for (const [dep, requiredVersion] of Object.entries(peerDeps)) {
+	if (!allDeps[dep]) {
+		missingDeps.push(`${dep}@${requiredVersion}`);
+		console.log(`❌ Missing: ${dep} (required: ${requiredVersion})`);
+	} else {
+		console.log(`✅ Found: ${dep}@${allDeps[dep]}`);
+		// Simple version check - could be improved
+		if (!allDeps[dep].includes('^') && !allDeps[dep].includes('~') && allDeps[dep] !== requiredVersion) {
+			outdatedDeps.push(`${dep} (installed: ${allDeps[dep]}, required: ${requiredVersion})`);
+		}
+	}
+}
+
+console.log('\n📊 Summary:');
+if (missingDeps.length === 0 && outdatedDeps.length === 0) {
+	console.log('✅ All peer dependencies are satisfied!');
+} else {
+	if (missingDeps.length > 0) {
+		console.log(`\n❌ Missing ${missingDeps.length} dependencies:`);
+		missingDeps.forEach(dep => console.log(`  - ${dep}`));
+		
+		if (shouldInstall) {
+			console.log('\n🔧 Auto-installing missing dependencies...\n');
+			
+			// Import and run the install-deps script
+			try {
+				const installDepsModule = await import('./install-deps.mjs');
+				// The install-deps script will handle the installation
+			} catch (error) {
+				console.error('❌ Failed to auto-install dependencies:', error.message);
+				process.exit(1);
+			}
+		} else {
+			console.log('\n💡 To install missing dependencies:');
+			console.log('   npx @dmitryrechkin/eslint-standard install-deps');
+			console.log('   or run this command with --install flag');
+		}
+	}
+	if (outdatedDeps.length > 0) {
+		console.log(`\n⚠️  ${outdatedDeps.length} dependencies may be outdated:`);
+		outdatedDeps.forEach(dep => console.log(`  - ${dep}`));
+	}
+	
+	if (!shouldInstall && missingDeps.length > 0) {
+		process.exit(1);
+	}
+}
+
+export default function checkDeps() {
+	// Export for programmatic use
+}

package/src/cli/index.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+
+switch (command) {
+	case 'install-deps':
+		await import('./install-deps.mjs');
+		break;
+	case 'check-deps':
+		await import('./check-deps.mjs');
+		break;
+	case 'help':
+	case '--help':
+	case '-h':
+	case undefined:
+		console.log(`
+@dmitryrechkin/eslint-standard CLI
+
+Usage:
+  npx @dmitryrechkin/eslint-standard <command>
+
+Commands:
+  install-deps         Install all peer dependencies
+  check-deps           Check if all peer dependencies are installed
+  check-deps --install Auto-install missing dependencies if any
+  help                 Show this help message
+
+Examples:
+  npx @dmitryrechkin/eslint-standard install-deps
+  npx @dmitryrechkin/eslint-standard check-deps
+  npx @dmitryrechkin/eslint-standard check-deps --install
+		`);
+		break;
+	default:
+		console.error(`Unknown command: ${command}`);
+		console.log('Run "npx @dmitryrechkin/eslint-standard help" for usage information');
+		process.exit(1);
+}

package/src/cli/install-deps.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Detect package manager
+function detectPackageManager() {
+	if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+	if (existsSync('yarn.lock')) return 'yarn';
+	if (existsSync('package-lock.json')) return 'npm';
+	if (existsSync('bun.lockb')) return 'bun';
+	return 'npm'; // default
+}
+
+// Get peer dependencies from package.json
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const peerDeps = packageJson.peerDependencies || {};
+
+// Build install command
+const packageManager = detectPackageManager();
+const deps = Object.entries(peerDeps).map(([name, version]) => `${name}@${version}`).join(' ');
+
+const installCommands = {
+	npm: `npm install --save-dev ${deps}`,
+	pnpm: `pnpm add -D ${deps}`,
+	yarn: `yarn add -D ${deps}`,
+	bun: `bun add -d ${deps}`
+};
+
+const command = installCommands[packageManager];
+
+console.log(`🔧 Installing ESLint Standard peer dependencies...`);
+console.log(`📦 Detected package manager: ${packageManager}`);
+console.log(`📋 Running: ${command}\n`);
+
+try {
+	execSync(command, { stdio: 'inherit' });
+	console.log('\n✅ All peer dependencies installed successfully!');
+} catch (error) {
+	console.error('\n❌ Failed to install dependencies. Please run manually:');
+	console.error(command);
+	process.exit(1);
+}

package/src/cli/postinstall-check.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Don't run during local development
+if (!__dirname.includes('node_modules')) {
+	process.exit(0);
+}
+
+// Check if we're in CI environment
+const isCI = process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS;
+
+// Check if scripts are disabled
+const npmConfigIgnoreScripts = process.env.npm_config_ignore_scripts === 'true';
+
+if (isCI || npmConfigIgnoreScripts) {
+	// Silent exit in CI or when scripts are disabled
+	process.exit(0);
+}
+
+// Simple check for missing dependencies
+try {
+	const packageJsonPath = join(__dirname, '../../package.json');
+	const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+	const peerDeps = Object.keys(packageJson.peerDependencies || {});
+	
+	// Quick check if any peer deps are missing
+	let missingCount = 0;
+	for (const dep of peerDeps) {
+		try {
+			// Try to resolve the dependency
+			require.resolve(dep, { paths: [process.cwd()] });
+		} catch {
+			missingCount++;
+		}
+	}
+	
+	if (missingCount > 0) {
+		console.log(`
+⚠️  @dmitryrechkin/eslint-standard: ${missingCount} peer dependencies are missing!
+
+Run this command to check and install them:
+👉 ${'\x1b[36m'}npx @dmitryrechkin/eslint-standard check-deps --install${'\x1b[0m'}
+`);
+	}
+} catch (error) {
+	// Silent fail - don't break installation
+}

package/src/cli/postinstall.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Don't run during local development
+if (!__dirname.includes('node_modules')) {
+	process.exit(0);
+}
+
+// Check environment variables for auto-install preference
+const autoInstall = process.env.ESLINT_STANDARD_AUTO_INSTALL === 'true';
+const skipInstall = process.env.ESLINT_STANDARD_SKIP_INSTALL === 'true';
+
+// Check if we're in CI environment
+const isCI = process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS;
+
+if (skipInstall || isCI) {
+	process.exit(0);
+}
+
+console.log(`
+╔════════════════════════════════════════════════════════════════╗
+║                                                                ║
+║   🎉 Thanks for installing @dmitryrechkin/eslint-standard!    ║
+║                                                                ║
+╚════════════════════════════════════════════════════════════════╝
+
+📦 This package requires peer dependencies to work properly.
+
+🚀 Quick install (auto-detects your package manager):
+   ${'\x1b[36m'}npx @dmitryrechkin/eslint-standard check-deps --install${'\x1b[0m'}
+
+📋 Or install all dependencies directly:
+   ${'\x1b[90m'}npm install -D eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-unused-imports @stylistic/eslint-plugin eslint-plugin-jsdoc eslint-plugin-simple-import-sort eslint-plugin-perfectionist${'\x1b[0m'}
+
+🔍 To check if all dependencies are installed:
+   ${'\x1b[36m'}npx @dmitryrechkin/eslint-standard check-deps${'\x1b[0m'}
+
+📚 Documentation: https://github.com/dmitryrechkin/eslint-standard
+`);
+
+// Don't run check-deps in postinstall to avoid errors
+// Users can run it manually with: npx @dmitryrechkin/eslint-standard check-deps
+
+if (autoInstall) {
+	console.log('\n🤖 Auto-install enabled via ESLINT_STANDARD_AUTO_INSTALL=true');
+	console.log('📦 Checking and installing peer dependencies...\n');
+	
+	try {
+		// Run check-deps with --install flag
+		const { execSync } = await import('child_process');
+		execSync('node ' + join(__dirname, 'index.mjs') + ' check-deps --install', {
+			stdio: 'inherit',
+			cwd: process.cwd()
+		});
+	} catch (error) {
+		console.error('❌ Auto-install failed. Please run manually:');
+		console.error('   npx @dmitryrechkin/eslint-standard check-deps --install');
+	}
+}

package/src/plugins/interface-brace.mjs

@@ -0,0 +1,121 @@
+/**
+ * Custom ESLint plugin to enforce Allman brace style for TypeScript interfaces
+ */
+
+const interfaceBraceRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce Allman brace style for TypeScript interfaces',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: []
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode || context.getSourceCode();
+
+		return {
+			TSInterfaceDeclaration(node) {
+				// Get the interface name token
+				const interfaceId = node.id;
+				const typeParams = node.typeParameters;
+				const extendsClause = node.extends;
+				
+				// Find the opening brace
+				let tokenBeforeBrace;
+				if (node.heritage && node.heritage.length > 0) {
+					// Interface extends something
+					tokenBeforeBrace = node.heritage[node.heritage.length - 1];
+				} else if (extendsClause && extendsClause.length > 0) {
+					// Interface extends something (newer AST)
+					tokenBeforeBrace = extendsClause[extendsClause.length - 1];
+				} else if (typeParams) {
+					// Interface has type parameters
+					tokenBeforeBrace = typeParams;
+				} else {
+					// Simple interface
+					tokenBeforeBrace = interfaceId;
+				}
+				
+				// Get the opening brace token
+				const openingBrace = sourceCode.getTokenAfter(tokenBeforeBrace, token => token.type === 'Punctuator' && token.value === '{');
+				
+				if (!openingBrace) return;
+				
+				// Check if there's a newline before the opening brace
+				const tokenBefore = sourceCode.getTokenBefore(openingBrace);
+				const textBetween = sourceCode.text.slice(tokenBefore.range[1], openingBrace.range[0]);
+				
+				// Check if brace is on the same line
+				if (!textBetween.includes('\n')) {
+					context.report({
+						node: openingBrace,
+						message: 'Opening brace should be on a new line (Allman style)',
+						fix(fixer) {
+							// Get the base indentation of the interface declaration
+							const interfaceLine = sourceCode.getLines()[node.loc.start.line - 1];
+							const baseIndentMatch = interfaceLine.match(/^(\s*)/);
+							const baseIndent = baseIndentMatch ? baseIndentMatch[1] : '';
+							
+							// Replace the space before the brace with a newline and proper indentation
+							return fixer.replaceTextRange(
+								[tokenBefore.range[1], openingBrace.range[0]], 
+								'\n' + baseIndent
+							);
+						}
+					});
+				}
+			},
+			
+			// Also handle TSTypeAliasDeclaration with object type
+			TSTypeAliasDeclaration(node) {
+				if (node.typeAnnotation && node.typeAnnotation.type === 'TSTypeLiteral') {
+					const typeParams = node.typeParameters;
+					const tokenBeforeBrace = typeParams ? typeParams : node.id;
+					
+					// Find the equals sign
+					const equalsToken = sourceCode.getTokenAfter(tokenBeforeBrace, token => token.type === 'Punctuator' && token.value === '=');
+					
+					if (!equalsToken) return;
+					
+					// Get the opening brace token
+					const openingBrace = sourceCode.getTokenAfter(equalsToken, token => token.type === 'Punctuator' && token.value === '{');
+					
+					if (!openingBrace) return;
+					
+					// Check if there's a newline before the opening brace
+					const textBetween = sourceCode.text.slice(equalsToken.range[1], openingBrace.range[0]);
+					
+					// Check if brace is on the same line
+					if (!textBetween.includes('\n')) {
+						context.report({
+							node: openingBrace,
+							message: 'Opening brace should be on a new line (Allman style)',
+							fix(fixer) {
+								// Get the base indentation
+								const typeLine = sourceCode.getLines()[node.loc.start.line - 1];
+								const baseIndentMatch = typeLine.match(/^(\s*)/);
+								const baseIndent = baseIndentMatch ? baseIndentMatch[1] : '';
+								
+								// Replace the space before the brace with a newline and proper indentation
+								return fixer.replaceTextRange(
+									[equalsToken.range[1], openingBrace.range[0]], 
+									' =\n' + baseIndent
+								);
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+export default {
+	rules: {
+		'interface-brace-style': interfaceBraceRule
+	}
+};