@dimensional-innovations/tool-config 3.1.0 → 5.0.0

package/src/detectors.js

@@ -1,286 +0,0 @@
-import { execSync } from 'child_process'
-import { existsSync } from 'fs'
-import { join } from 'path'
-
-import { getAllDependencies, readPackageJson } from './utils/package-reader.js'
-
-/**
- * Check for React meta-frameworks
- */
-function detectReactMetaFramework(deps) {
-  return (
-    deps.next ||
-    deps['@next/core'] ||
-    deps.remix ||
-    deps['@remix-run/react'] ||
-    deps['@remix-run/node'] ||
-    deps.gatsby ||
-    deps['gatsby-link']
-  )
-}
-
-/**
- * Check for Vue meta-frameworks
- */
-function detectVueMetaFramework(deps) {
-  return deps.nuxt || deps['nuxt3']
-}
-
-/**
- * Check for Svelte meta-frameworks
- */
-function detectSvelteMetaFramework(deps) {
-  return deps['@sveltejs/kit']
-}
-
-/**
- * Check for base framework dependencies
- */
-function detectBaseFramework(deps) {
-  if (deps.react || deps['react-dom']) return 'react'
-  if (deps.vue || deps['@vue/runtime-core'] || deps['vue-router'] || deps.pinia) return 'vue'
-  if (deps['@angular/core']) return 'angular'
-  if (deps.svelte) return 'svelte'
-  if (deps['solid-js']) return 'solid'
-  if (deps.astro) return 'astro'
-  return null
-}
-
-/**
- * Check if project is a Node.js backend
- */
-function isNodeBackend(pkg, deps, cwd) {
-  if (pkg.type !== 'module') return false
-
-  const hasNodeFramework = deps.express || deps.fastify || deps.koa || deps['@hapi/hapi']
-  const hasServerFiles =
-    existsSync(join(cwd, 'server.js')) ||
-    existsSync(join(cwd, 'app.js')) ||
-    (existsSync(join(cwd, 'index.js')) && existsSync(join(cwd, 'routes')))
-
-  return hasNodeFramework || hasServerFiles
-}
-
-/**
- * Detect the framework being used in the project
- * @param {string} cwd - Current working directory
- * @returns {string} Detected framework name
- */
-export function detectFramework(cwd = process.cwd()) {
-  const pkg = readPackageJson(cwd)
-
-  if (!pkg) {
-    console.warn('⚠️  Could not find package.json, defaulting to vanilla JavaScript')
-    return 'vanilla'
-  }
-
-  const deps = getAllDependencies(pkg)
-
-  // Check meta-frameworks first
-  if (detectReactMetaFramework(deps)) return 'react'
-  if (detectVueMetaFramework(deps)) return 'vue'
-  if (detectSvelteMetaFramework(deps)) return 'svelte'
-
-  // Check base frameworks
-  const baseFramework = detectBaseFramework(deps)
-  if (baseFramework) return baseFramework
-
-  // Check Node.js backend
-  if (isNodeBackend(pkg, deps, cwd)) return 'node'
-
-  // Default to vanilla JavaScript
-  return 'vanilla'
-}
-
-/**
- * Detect the environment (browser, node, or universal)
- * @param {string} framework - Detected framework
- * @param {string} cwd - Current working directory
- * @returns {string} Environment type
- */
-export function detectEnvironment(framework, cwd = process.cwd()) {
-  // Framework-specific defaults
-  if (framework === 'node') {
-    return 'node'
-  }
-
-  // Frontend frameworks default to browser
-  if (['react', 'vue', 'svelte', 'solid', 'angular'].includes(framework)) {
-    return 'browser'
-  }
-
-  // Astro uses islands architecture (both browser and node)
-  if (framework === 'astro') {
-    return 'universal'
-  }
-
-  // Check for mixed environment indicators
-  const hasServerCode =
-    existsSync(join(cwd, 'server')) ||
-    existsSync(join(cwd, 'api')) ||
-    existsSync(join(cwd, 'backend'))
-
-  if (hasServerCode) {
-    return 'universal'
-  }
-
-  // Default to browser for frontend projects
-  return 'browser'
-}
-
-/**
- * Detect if TypeScript is being used
- * @param {string} cwd - Current working directory
- * @returns {boolean} True if TypeScript is detected
- */
-export function detectTypeScript(cwd = process.cwd()) {
-  // Check for tsconfig.json
-  if (existsSync(join(cwd, 'tsconfig.json'))) {
-    return true
-  }
-
-  // Check for TypeScript in dependencies or devDependencies
-  const pkg = readPackageJson(cwd)
-  if (!pkg) return false
-
-  // TypeScript is typically a devDependency
-  return !!(pkg.dependencies?.typescript || pkg.devDependencies?.typescript)
-}
-
-/**
- * Detect Git provider from repository URL
- * @param {string} cwd - Current working directory
- * @returns {string} Git provider ('gitlab', 'github', 'bitbucket', or null)
- */
-export function detectGitProvider(cwd = process.cwd()) {
-  // Try package.json repository field first
-  const pkg = readPackageJson(cwd)
-  if (pkg?.repository) {
-    const repoUrl = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository.url || ''
-
-    if (repoUrl.includes('gitlab.com')) return 'gitlab'
-    if (repoUrl.includes('github.com')) return 'github'
-    if (repoUrl.includes('bitbucket.org')) return 'bitbucket'
-
-    // If repository field exists but provider not recognized, return null
-    // Don't fallback to git remote if package.json explicitly specifies a repo
-    return null
-  }
-
-  // Try git remote as fallback only if no repository field in package.json
-  try {
-    const remoteUrl = execSync('git remote get-url origin', {
-      cwd,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'ignore']
-    }).trim()
-
-    if (remoteUrl.includes('gitlab.com')) return 'gitlab'
-    if (remoteUrl.includes('github.com')) return 'github'
-    if (remoteUrl.includes('bitbucket.org')) return 'bitbucket'
-  } catch {
-    // Git command failed or not a git repository
-  }
-
-  // Default to null (no provider detected)
-  return null
-}
-
-/**
- * Detect CSS type and variants
- * @param {string} cwd - Current working directory
- * @returns {Object} CSS type detection results
- */
-export function detectCssType(cwd = process.cwd()) {
-  const pkg = readPackageJson(cwd)
-
-  const results = {
-    preprocessor: null, // 'scss', 'sass', 'less', null
-    tailwind: false,
-    modules: false,
-    postcss: false
-  }
-
-  // Detect SCSS/Sass
-  const hasSass =
-    pkg?.dependencies?.sass ||
-    pkg?.devDependencies?.sass ||
-    pkg?.dependencies?.['node-sass'] ||
-    pkg?.devDependencies?.['node-sass'] ||
-    pkg?.dependencies?.['sass-embedded'] ||
-    pkg?.devDependencies?.['sass-embedded']
-
-  if (hasSass) {
-    results.preprocessor = 'scss'
-  }
-
-  // Detect Less
-  const hasLess = pkg?.dependencies?.less || pkg?.devDependencies?.less
-
-  if (hasLess && !hasSass) {
-    // SCSS takes precedence if both exist
-    results.preprocessor = 'less'
-  }
-
-  // Detect Tailwind CSS
-  const hasTailwind = pkg?.dependencies?.tailwindcss || pkg?.devDependencies?.tailwindcss
-
-  if (hasTailwind) {
-    // Check for config file
-    results.tailwind =
-      existsSync(join(cwd, 'tailwind.config.js')) ||
-      existsSync(join(cwd, 'tailwind.config.ts')) ||
-      existsSync(join(cwd, 'tailwind.config.mjs')) ||
-      existsSync(join(cwd, 'tailwind.config.cjs'))
-  }
-
-  // Detect PostCSS config
-  results.postcss =
-    existsSync(join(cwd, 'postcss.config.js')) ||
-    existsSync(join(cwd, 'postcss.config.cjs')) ||
-    existsSync(join(cwd, 'postcss.config.mjs')) ||
-    existsSync(join(cwd, '.postcssrc')) ||
-    existsSync(join(cwd, '.postcssrc.json'))
-
-  // Note: CSS Modules detection is tricky without scanning files
-  // Framework-based heuristic: React/Next.js projects often use CSS Modules
-  // Will be set to true if React/Next.js detected (handled in Stylelint factory)
-
-  return results
-}
-
-/**
- * Detect if project is an Electron application
- * @param {string} cwd - Current working directory
- * @returns {boolean} True if Electron project detected
- */
-export function detectElectron(cwd = process.cwd()) {
-  const pkg = readPackageJson(cwd)
-  if (!pkg) return false
-
-  const deps = getAllDependencies(pkg)
-  return !!(deps.electron || deps['@electron-toolkit/utils'] || deps['@electron-toolkit/preload'])
-}
-
-/**
- * Auto-detect all configuration options
- * @param {string} cwd - Current working directory
- * @returns {Object} Detected configuration
- */
-export function autoDetect(cwd = process.cwd()) {
-  const framework = detectFramework(cwd)
-  const environment = detectEnvironment(framework, cwd)
-  const typescript = detectTypeScript(cwd)
-  const gitProvider = detectGitProvider(cwd)
-  const cssType = detectCssType(cwd)
-  const electron = detectElectron(cwd)
-
-  return {
-    framework,
-    environment,
-    typescript,
-    gitProvider,
-    cssType,
-    electron
-  }
-}

package/src/index.js

@@ -1,69 +0,0 @@
-/**
- * @dimensional-innovations/tool-config
- * Universal configuration package for development tools
- *
- * Supports: ESLint, Prettier, Stylelint, semantic-release, TypeScript
- * Auto-detects: React, Vue, Svelte, Solid, Astro, Angular, Vanilla JS, Node.js
- */
-
-/**
- * Create a configuration for a specific tool
- *
- * @param {string} tool - Tool name ('eslint' | 'prettier' | 'stylelint' | 'semantic-release' | 'typescript')
- * @param {Object} options - Configuration options
- * @returns {Promise<any>|any} Tool-specific configuration
- *
- * @example
- * // ESLint configuration
- * import { createConfig } from '@dimensional-innovations/tool-config';
- * export default await createConfig('eslint', {
- *   framework: 'auto',
- *   environment: 'auto',
- *   typescript: 'auto'
- * });
- *
- * @example
- * // Prettier configuration
- * import { createConfig } from '@dimensional-innovations/tool-config';
- * export default createConfig('prettier', {
- *   framework: 'auto'
- * });
- */
-export async function createConfig(tool, options = {}) {
-  switch (tool) {
-    case 'eslint': {
-      const { createEslintConfig } = await import('./tools/eslint/index.js')
-      return createEslintConfig(options)
-    }
-    case 'prettier': {
-      const { createPrettierConfig } = await import('./tools/prettier/index.js')
-      return createPrettierConfig(options)
-    }
-    case 'stylelint': {
-      const { createStylelintConfig } = await import('./tools/stylelint/index.js')
-      return createStylelintConfig(options)
-    }
-    case 'semantic-release': {
-      const { createReleaseConfig } = await import('./tools/semantic-release/index.js')
-      return createReleaseConfig(options)
-    }
-    case 'typescript': {
-      const { createTypescriptConfig } = await import('./tools/typescript/index.js')
-      return createTypescriptConfig(options)
-    }
-    default:
-      throw new Error(
-        `Unknown tool: "${tool}". Supported tools: eslint, prettier, stylelint, semantic-release, typescript`
-      )
-  }
-}
-
-// Named exports for convenience
-export { createEslintConfig } from './tools/eslint/index.js'
-export { createPrettierConfig } from './tools/prettier/index.js'
-export { createStylelintConfig } from './tools/stylelint/index.js'
-export { createReleaseConfig } from './tools/semantic-release/index.js'
-export { createTypescriptConfig } from './tools/typescript/index.js'
-
-// Re-export detection utilities for advanced users
-export { autoDetect, detectFramework, detectEnvironment, detectTypeScript } from './detectors.js'

package/src/tools/eslint/index.js

@@ -1,282 +0,0 @@
-import js from '@eslint/js'
-import tseslint from 'typescript-eslint'
-
-import { autoDetect } from '../../detectors.js'
-import { getEslintIgnores } from '../../utils/ignore-patterns.js'
-
-import basePreset from './presets/base.js'
-import browserEnv from './presets/environments/browser.js'
-import nodeEnv from './presets/environments/node.js'
-import universalEnv from './presets/environments/universal.js'
-import createAngularPreset from './presets/frameworks/angular.js'
-import createNodePreset from './presets/frameworks/node.js'
-import createReactPreset from './presets/frameworks/react.js'
-import createVanillaPreset from './presets/frameworks/vanilla.js'
-import createVuePreset from './presets/frameworks/vue.js'
-import importsPreset from './presets/imports.js'
-import typescriptPreset from './presets/typescript.js'
-
-/**
- * File patterns for all supported source file types
- */
-const SOURCE_FILES = [
-  '**/*.js',
-  '**/*.ts',
-  '**/*.tsx',
-  '**/*.vue',
-  '**/*.jsx',
-  '**/*.svelte',
-  '**/*.astro'
-]
-
-/**
- * Add framework-specific configuration to config array
- * Supports lazy loading for Svelte, Solid, and Astro to avoid requiring optional peer dependencies
- *
- * @param {Array} config - ESLint flat config array to append framework presets to
- * @param {string} framework - Framework name ('react' | 'vue' | 'svelte' | 'solid' | 'astro' | 'angular' | 'vanilla' | 'node')
- * @returns {Promise<void>}
- */
-async function addFrameworkConfig(config, framework) {
-  switch (framework) {
-    case 'react':
-      config.push(...createReactPreset())
-      break
-    case 'vue':
-      config.push(...createVuePreset())
-      break
-    case 'svelte': {
-      const { default: createSveltePreset } = await import('./presets/frameworks/svelte.js')
-      config.push(...createSveltePreset())
-      break
-    }
-    case 'solid': {
-      const { default: createSolidPreset } = await import('./presets/frameworks/solid.js')
-      config.push(...createSolidPreset())
-      break
-    }
-    case 'astro': {
-      const { default: createAstroPreset } = await import('./presets/frameworks/astro.js')
-      config.push(...createAstroPreset())
-      break
-    }
-    case 'vanilla':
-      config.push(...createVanillaPreset())
-      break
-    case 'node':
-      config.push(...createNodePreset())
-      break
-    case 'angular':
-      config.push(...createAngularPreset())
-      break
-    default:
-      console.warn(`⚠️  Unknown framework "${framework}", defaulting to vanilla JavaScript`)
-      config.push(...createVanillaPreset())
-      break
-  }
-}
-
-/**
- * Get environment configuration based on detected or specified environment
- * Returns globals and languageOptions for browser, node, or universal environments
- *
- * @param {string} environment - Environment type ('browser' | 'node' | 'universal')
- * @returns {Object} Environment configuration object with languageOptions
- */
-function getEnvironmentConfig(environment) {
-  switch (environment) {
-    case 'node':
-      return nodeEnv
-    case 'universal':
-      return universalEnv
-    case 'browser':
-    default:
-      return browserEnv
-  }
-}
-
-/**
- * Add TypeScript configuration to config array
- * Includes recommended TypeScript rules with relaxed settings for .d.ts and .js files
- *
- * @param {Array} config - ESLint flat config array to append TypeScript presets to
- * @returns {void}
- */
-function addTypeScriptConfig(config) {
-  config.push(...tseslint.configs.recommended)
-  config.push({
-    files: SOURCE_FILES,
-    ...typescriptPreset
-  })
-
-  config.push({
-    files: ['**/*.d.ts'],
-    rules: {
-      '@typescript-eslint/no-explicit-any': 'off'
-    }
-  })
-
-  config.push({
-    files: ['**/*.js'],
-    rules: {
-      '@typescript-eslint/no-var-requires': 'off'
-    }
-  })
-}
-
-/**
- * Add test and script overrides to config array
- * Relaxes rules for test files and CLI scripts, and applies user-provided rule overrides
- *
- * @param {Array} config - ESLint flat config array to append overrides to
- * @param {Object} options - Configuration options containing user rule overrides
- * @param {Object} [options.rules] - User-provided rule overrides
- * @returns {void}
- */
-function addOverrides(config, options) {
-  // Test files override
-  config.push({
-    files: ['tests/**/*.{js,ts,jsx,tsx,vue,svelte,astro}'],
-    rules: {
-      'no-console': 'off',
-      'max-lines-per-function': 'off',
-      complexity: 'off',
-      'max-statements': 'off',
-      'max-nested-callbacks': 'off',
-      'no-magic-numbers': 'off',
-      '@typescript-eslint/no-explicit-any': 'off'
-    }
-  })
-
-  // Node.js scripts override
-  config.push({
-    files: ['**/bin/**/*.js', '**/scripts/**/*.js'],
-    languageOptions: {
-      globals: {
-        ...nodeEnv.languageOptions.globals
-      }
-    },
-    rules: {
-      'no-console': 'off',
-      'max-lines-per-function': 'off'
-    }
-  })
-
-  // User-provided rule overrides
-  if (options.rules && Object.keys(options.rules).length > 0) {
-    config.push({
-      files: SOURCE_FILES,
-      rules: options.rules
-    })
-  }
-}
-
-/**
- * Create an ESLint flat config
- *
- * Supports: React, Vue.js, Svelte, Solid, Astro, Angular, Vanilla JS/TS, and auto-detection
- *
- * @param {Object} options - Configuration options
- * @param {string} [options.framework='auto'] - Framework: 'auto' | 'react' | 'vue' | 'svelte' | 'solid' | 'astro' | 'angular' | 'vanilla' | 'node'
- * @param {string} [options.environment='auto'] - Environment: 'auto' | 'browser' | 'node' | 'universal'
- * @param {boolean|string} [options.typescript='auto'] - TypeScript: 'auto' | true | false
- * @param {string[]} [options.ignorePaths=[]] - Additional paths to ignore during linting
- * @param {Object} [options.rules={}] - Additional rule overrides
- * @param {string} [options.cwd] - Current working directory for detection
- * @returns {Promise<Array>} ESLint flat config array
- *
- * @example
- * // Zero config - auto-detects everything
- * import { createEslintConfig } from '@dimensional-innovations/tool-config';
- * export default await createEslintConfig();
- *
- * @example
- * // Explicit configuration
- * import { createEslintConfig } from '@dimensional-innovations/tool-config';
- * export default await createEslintConfig({
- *   framework: 'react',
- *   environment: 'browser',
- *   typescript: true
- * });
- *
- * @example
- * // With custom rules
- * import { createEslintConfig } from '@dimensional-innovations/tool-config';
- * export default await createEslintConfig({
- *   rules: {
- *     'no-console': 'off'
- *   }
- * });
- */
-export async function createEslintConfig(options = {}) {
-  const cwd = options.cwd || process.cwd()
-  const detected = autoDetect(cwd)
-
-  const framework =
-    options.framework === 'auto' || !options.framework ? detected.framework : options.framework
-  const environment =
-    options.environment === 'auto' || !options.environment
-      ? detected.environment
-      : options.environment
-  const typescript =
-    options.typescript === 'auto' || options.typescript === undefined
-      ? detected.typescript
-      : options.typescript
-
-  console.log(
-    `📦 ESLint Config: ${framework} | ${environment} | TypeScript: ${typescript ? 'Yes' : 'No'}`
-  )
-
-  if (framework === 'angular') {
-    console.warn(
-      '\n⚠️  Angular detected. This package provides basic TypeScript linting.\n' +
-        '   For Angular-specific rules, install: @angular-eslint/eslint-plugin\n' +
-        '   See: https://github.com/angular-eslint/angular-eslint\n'
-    )
-  }
-
-  const defaultIgnorePaths = getEslintIgnores()
-  const allIgnorePaths = [...defaultIgnorePaths, ...(options.ignorePaths || [])]
-
-  const config = []
-
-  // 1. Ignore paths
-  config.push({ ignores: allIgnorePaths })
-
-  // 2. ESLint recommended rules
-  config.push(js.configs.recommended)
-
-  // 3. TypeScript configuration
-  if (typescript) {
-    addTypeScriptConfig(config)
-  }
-
-  // 4. Environment configuration
-  const envConfig = getEnvironmentConfig(environment)
-  config.push({
-    files: SOURCE_FILES,
-    ...envConfig
-  })
-
-  // 5. Base JavaScript rules
-  config.push({
-    files: SOURCE_FILES,
-    ...basePreset
-  })
-
-  // 6. Import/export rules
-  config.push({
-    files: SOURCE_FILES,
-    ...importsPreset
-  })
-
-  // 7. Framework-specific configuration
-  await addFrameworkConfig(config, framework)
-
-  // 8. Test files and script overrides
-  addOverrides(config, options)
-
-  return config
-}
-
-export default createEslintConfig