@monoes/monograph 1.5.6 → 1.5.8

package/src/config/plugins/builtin.ts

@@ -1,411 +0,0 @@
-import { type BuiltinPlugin, type PluginRegistry } from './types.js';
-import { createPluginRegistry } from './registry.js';
-
-export const BUILTIN_PLUGINS: BuiltinPlugin[] = [
-  {
-    name: 'eslint',
-    configPatterns: [
-      'eslint.config.*',
-      '.eslintrc',
-      '.eslintrc.js',
-      '.eslintrc.cjs',
-      '.eslintrc.mjs',
-      '.eslintrc.json',
-      '.eslintrc.yaml',
-      '.eslintrc.yml',
-      '.eslintignore',
-    ],
-    toolingPackages: ['eslint', '@eslint/', 'eslint-plugin-', 'eslint-config-'],
-    typesPackages: [],
-  },
-  {
-    name: 'prettier',
-    configPatterns: [
-      '.prettierrc',
-      '.prettierrc.js',
-      '.prettierrc.cjs',
-      '.prettierrc.mjs',
-      '.prettierrc.json',
-      '.prettierrc.json5',
-      '.prettierrc.yaml',
-      '.prettierrc.yml',
-      '.prettierrc.toml',
-      'prettier.config.js',
-      'prettier.config.cjs',
-      'prettier.config.mjs',
-      '.prettierignore',
-    ],
-    toolingPackages: ['prettier', 'prettier-plugin-'],
-  },
-  {
-    name: '@biomejs/biome',
-    configPatterns: ['biome.json', 'biome.jsonc'],
-    toolingPackages: ['@biomejs/biome'],
-  },
-  {
-    name: 'stylelint',
-    configPatterns: [
-      '.stylelintrc',
-      '.stylelintrc.js',
-      '.stylelintrc.cjs',
-      '.stylelintrc.mjs',
-      '.stylelintrc.json',
-      '.stylelintrc.yaml',
-      '.stylelintrc.yml',
-      'stylelint.config.js',
-      'stylelint.config.cjs',
-      'stylelint.config.mjs',
-    ],
-    toolingPackages: ['stylelint', 'stylelint-config-', 'stylelint-plugin-'],
-  },
-  {
-    name: 'oxlint',
-    configPatterns: ['oxlint.json', '.oxlintrc', '.oxlintrc.json'],
-    toolingPackages: ['oxlint'],
-  },
-  {
-    name: 'jest',
-    configPatterns: [
-      'jest.config.js',
-      'jest.config.cjs',
-      'jest.config.mjs',
-      'jest.config.ts',
-      'jest.config.cts',
-      'jest.config.mts',
-      'jest.config.json',
-      'jest.setup.js',
-      'jest.setup.ts',
-      'jest.setup.cjs',
-      'jest.setup.mjs',
-    ],
-    toolingPackages: ['jest', '@jest/', 'jest-'],
-    entryPatterns: ['**/__tests__/**/*.{js,ts,jsx,tsx}', '**/*.{spec,test}.{js,ts,jsx,tsx}'],
-    typesPackages: ['jest'],
-  },
-  {
-    name: 'vitest',
-    configPatterns: [
-      'vitest.config.js',
-      'vitest.config.cjs',
-      'vitest.config.mjs',
-      'vitest.config.ts',
-      'vitest.config.cts',
-      'vitest.config.mts',
-      'vitest.setup.js',
-      'vitest.setup.ts',
-    ],
-    toolingPackages: ['vitest', '@vitest/'],
-    entryPatterns: ['**/*.{spec,test}.{js,ts,jsx,tsx}'],
-    typesPackages: ['vitest'],
-  },
-  {
-    name: '@playwright/test',
-    configPatterns: [
-      'playwright.config.js',
-      'playwright.config.ts',
-      'playwright.config.mjs',
-      'playwright.config.cjs',
-    ],
-    toolingPackages: ['@playwright/test', 'playwright'],
-    typesPackages: ['playwright'],
-  },
-  {
-    name: 'cypress',
-    configPatterns: [
-      'cypress.config.js',
-      'cypress.config.ts',
-      'cypress.config.cjs',
-      'cypress.config.mjs',
-      'cypress/**',
-    ],
-    toolingPackages: ['cypress'],
-    entryPatterns: ['cypress/e2e/**/*.{js,ts,jsx,tsx}', 'cypress/integration/**/*.{js,ts,jsx,tsx}'],
-    typesPackages: ['cypress'],
-  },
-  {
-    name: 'mocha',
-    configPatterns: [
-      '.mocharc.js',
-      '.mocharc.cjs',
-      '.mocharc.mjs',
-      '.mocharc.json',
-      '.mocharc.jsonc',
-      '.mocharc.yaml',
-      '.mocharc.yml',
-    ],
-    toolingPackages: ['mocha', '@types/mocha'],
-    typesPackages: ['mocha'],
-  },
-  {
-    name: 'vite',
-    configPatterns: [
-      'vite.config.js',
-      'vite.config.ts',
-      'vite.config.mjs',
-      'vite.config.cjs',
-      'vite.config.mts',
-      'vite.config.cts',
-    ],
-    toolingPackages: ['vite', '@vitejs/'],
-  },
-  {
-    name: 'webpack',
-    configPatterns: [
-      'webpack.config.js',
-      'webpack.config.ts',
-      'webpack.config.mjs',
-      'webpack.config.cjs',
-      'webpack.config.babel.js',
-    ],
-    toolingPackages: ['webpack', 'webpack-cli', 'webpack-dev-server', 'webpack-merge', 'webpack-plugin-'],
-  },
-  {
-    name: 'rollup',
-    configPatterns: [
-      'rollup.config.js',
-      'rollup.config.ts',
-      'rollup.config.mjs',
-      'rollup.config.cjs',
-    ],
-    toolingPackages: ['rollup', '@rollup/'],
-  },
-  {
-    name: 'esbuild',
-    configPatterns: [
-      'esbuild.config.js',
-      'esbuild.config.ts',
-      'esbuild.config.mjs',
-      'esbuild.config.cjs',
-      'build.js',
-      'build.ts',
-    ],
-    toolingPackages: ['esbuild'],
-  },
-  {
-    name: 'tsup',
-    configPatterns: [
-      'tsup.config.js',
-      'tsup.config.ts',
-      'tsup.config.mjs',
-      'tsup.config.cjs',
-      'tsup.config.json',
-    ],
-    toolingPackages: ['tsup'],
-  },
-  {
-    name: 'parcel',
-    configPatterns: ['.parcelrc', '.parcelrc.json'],
-    toolingPackages: ['parcel', '@parcel/'],
-  },
-  {
-    name: '@babel/core',
-    configPatterns: [
-      'babel.config.js',
-      'babel.config.cjs',
-      'babel.config.mjs',
-      'babel.config.json',
-      'babel.config.ts',
-      '.babelrc',
-      '.babelrc.js',
-      '.babelrc.cjs',
-      '.babelrc.mjs',
-      '.babelrc.json',
-    ],
-    toolingPackages: ['@babel/', 'babel-plugin-', 'babel-preset-'],
-  },
-  {
-    name: '@swc/core',
-    configPatterns: [
-      '.swcrc',
-      'swc.config.js',
-      'swc.config.ts',
-      'swc.config.mjs',
-      'swc.config.cjs',
-    ],
-    toolingPackages: ['@swc/', 'swc-'],
-  },
-  {
-    name: 'nx',
-    configPatterns: ['nx.json', 'project.json', '.nxignore'],
-    toolingPackages: ['nx', '@nx/'],
-  },
-  {
-    name: 'turbo',
-    configPatterns: ['turbo.json'],
-    toolingPackages: ['turbo', 'turborepo'],
-  },
-  {
-    name: 'lerna',
-    configPatterns: ['lerna.json'],
-    toolingPackages: ['lerna'],
-  },
-  {
-    name: '@changesets/cli',
-    configPatterns: ['.changeset/config.json', '.changeset/*.md'],
-    toolingPackages: ['@changesets/'],
-  },
-  {
-    name: 'husky',
-    configPatterns: [
-      '.husky/**',
-      '.huskyrc',
-      '.huskyrc.js',
-      '.huskyrc.json',
-      '.huskyrc.yaml',
-      '.huskyrc.yml',
-    ],
-    toolingPackages: ['husky'],
-  },
-  {
-    name: 'lint-staged',
-    configPatterns: [
-      '.lintstagedrc',
-      '.lintstagedrc.js',
-      '.lintstagedrc.cjs',
-      '.lintstagedrc.mjs',
-      '.lintstagedrc.json',
-      '.lintstagedrc.yaml',
-      '.lintstagedrc.yml',
-      'lint-staged.config.js',
-      'lint-staged.config.cjs',
-      'lint-staged.config.mjs',
-      'lint-staged.config.ts',
-    ],
-    toolingPackages: ['lint-staged'],
-  },
-  {
-    name: '@commitlint/cli',
-    configPatterns: [
-      'commitlint.config.js',
-      'commitlint.config.cjs',
-      'commitlint.config.mjs',
-      'commitlint.config.ts',
-      '.commitlintrc',
-      '.commitlintrc.js',
-      '.commitlintrc.cjs',
-      '.commitlintrc.mjs',
-      '.commitlintrc.json',
-      '.commitlintrc.yaml',
-      '.commitlintrc.yml',
-    ],
-    toolingPackages: ['@commitlint/'],
-  },
-  {
-    name: '@storybook/core',
-    configPatterns: [
-      '.storybook/**',
-      'storybook.config.js',
-      'storybook.config.ts',
-    ],
-    toolingPackages: ['@storybook/', 'storybook'],
-    entryPatterns: ['**/*.stories.{js,ts,jsx,tsx,mdx}'],
-  },
-  {
-    name: 'typescript',
-    configPatterns: [
-      'tsconfig.json',
-      'tsconfig.*.json',
-      'tsconfig.*.jsonc',
-    ],
-    toolingPackages: ['typescript', 'ts-node', 'ts-jest', 'tsx'],
-  },
-  {
-    name: 'docker',
-    configPatterns: [
-      'Dockerfile',
-      'Dockerfile.*',
-      'docker-compose.yml',
-      'docker-compose.yaml',
-      'docker-compose.*.yml',
-      'docker-compose.*.yaml',
-      '.dockerignore',
-    ],
-    toolingPackages: [],
-  },
-  {
-    name: 'vercel',
-    configPatterns: ['vercel.json', '.vercelignore'],
-    toolingPackages: ['vercel', '@vercel/'],
-  },
-  {
-    name: 'netlify',
-    configPatterns: [
-      'netlify.toml',
-      '_redirects',
-      '_headers',
-    ],
-    toolingPackages: ['netlify-cli', 'netlify-lambda'],
-  },
-];
-
-export const DEFAULT_PLUGIN_REGISTRY: PluginRegistry = createPluginRegistry(BUILTIN_PLUGINS);
-
-export const ALWAYS_DEV_TOOLING: string[] = [
-  '@types/',
-  'eslint',
-  'prettier',
-  'jest',
-  'vitest',
-  'mocha',
-  'chai',
-  'sinon',
-  'jasmine',
-  '@jest/',
-  '@vitest/',
-  'typescript',
-  'ts-node',
-  'tsx',
-  'ts-jest',
-  'webpack',
-  'webpack-cli',
-  'webpack-dev-server',
-  'rollup',
-  'vite',
-  '@vitejs/',
-  'esbuild',
-  'tsup',
-  'parcel',
-  '@parcel/',
-  '@babel/',
-  'babel-plugin-',
-  'babel-preset-',
-  '@swc/',
-  'eslint-plugin-',
-  'eslint-config-',
-  '@eslint/',
-  'stylelint',
-  'stylelint-config-',
-  'stylelint-plugin-',
-  'oxlint',
-  '@biomejs/biome',
-  'prettier-plugin-',
-  'husky',
-  'lint-staged',
-  '@commitlint/',
-  'commitizen',
-  '@changesets/',
-  'lerna',
-  'turbo',
-  'nx',
-  '@nx/',
-  '@storybook/',
-  'storybook',
-  '@playwright/test',
-  'playwright',
-  'cypress',
-  'nodemon',
-  'concurrently',
-  'cross-env',
-  'rimraf',
-  'del-cli',
-  'npm-run-all',
-  'wait-on',
-  'dotenv-cli',
-  'standard-version',
-  'semantic-release',
-  '@semantic-release/',
-  'release-it',
-  'auto',
-  'size-limit',
-  'bundlesize',
-];

package/src/config/plugins/registry.ts

@@ -1,77 +0,0 @@
-import { type BuiltinPlugin, type PluginRegistry } from './types.js';
-
-export function matchGlob(pattern: string, filePath: string): boolean {
-  const normalized = filePath.replace(/\\/g, '/');
-  const escaped = pattern
-    .replace(/\\/g, '/')
-    .replace(/[.+^${}()|[\]]/g, '\\$&')
-    .replace(/\*\*/g, '\x00')
-    .replace(/\*/g, '[^/]*')
-    .replace(/\?/g, '[^/]')
-    .replace(/\x00/g, '.*');
-  const regex = new RegExp(`^${escaped}$`);
-  if (regex.test(normalized)) return true;
-  const basename = normalized.split('/').pop() ?? normalized;
-  const baseEscaped = pattern
-    .replace(/\\/g, '/')
-    .replace(/[.+^${}()|[\]]/g, '\\$&')
-    .replace(/\*\*/g, '\x00')
-    .replace(/\*/g, '[^/]*')
-    .replace(/\?/g, '[^/]')
-    .replace(/\x00/g, '.*');
-  if (!pattern.includes('/')) {
-    return new RegExp(`^${baseEscaped}$`).test(basename);
-  }
-  return false;
-}
-
-function isInstalled(pluginName: string, installedPackages: string[]): boolean {
-  return installedPackages.some(
-    (pkg) => pkg === pluginName || pkg.startsWith(pluginName + '/'),
-  );
-}
-
-export function createPluginRegistry(plugins: BuiltinPlugin[]): PluginRegistry {
-  return {
-    getConfigPatterns(installedPackages: string[]): string[] {
-      const seen = new Set<string>();
-      const result: string[] = [];
-      for (const plugin of plugins) {
-        if (!isInstalled(plugin.name, installedPackages)) continue;
-        for (const pat of plugin.configPatterns) {
-          if (!seen.has(pat)) { seen.add(pat); result.push(pat); }
-        }
-      }
-      return result;
-    },
-
-    getToolingPackages(installedPackages: string[]): string[] {
-      const seen = new Set<string>();
-      const result: string[] = [];
-      for (const plugin of plugins) {
-        if (!isInstalled(plugin.name, installedPackages)) continue;
-        for (const pkg of plugin.toolingPackages ?? []) {
-          if (!seen.has(pkg)) { seen.add(pkg); result.push(pkg); }
-        }
-      }
-      return result;
-    },
-
-    getEntryPatterns(installedPackages: string[]): string[] {
-      const seen = new Set<string>();
-      const result: string[] = [];
-      for (const plugin of plugins) {
-        if (!isInstalled(plugin.name, installedPackages)) continue;
-        for (const pat of plugin.entryPatterns ?? []) {
-          if (!seen.has(pat)) { seen.add(pat); result.push(pat); }
-        }
-      }
-      return result;
-    },
-
-    isAlwaysUsed(filePath: string, installedPackages: string[]): boolean {
-      const patterns = this.getConfigPatterns(installedPackages);
-      return patterns.some((pat) => matchGlob(pat, filePath));
-    },
-  };
-}

package/src/config/plugins/types.ts

@@ -1,14 +0,0 @@
-export interface BuiltinPlugin {
-  name: string;
-  configPatterns: string[];
-  toolingPackages?: string[];
-  entryPatterns?: string[];
-  typesPackages?: string[];
-}
-
-export interface PluginRegistry {
-  getConfigPatterns(installedPackages: string[]): string[];
-  getToolingPackages(installedPackages: string[]): string[];
-  getEntryPatterns(installedPackages: string[]): string[];
-  isAlwaysUsed(filePath: string, installedPackages: string[]): boolean;
-}

package/src/config/resolution.ts

@@ -1,102 +0,0 @@
-// Config resolution system: merges base configs via extends chains.
-
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-
-export type ExtendsSource =
-  | { kind: 'file'; path: string }
-  | { kind: 'npm'; packageName: string }
-  | { kind: 'url'; url: string };
-
-export interface ResolvedInheritance {
-  source: ExtendsSource;
-  config: Record<string, unknown>;
-}
-
-export function parseExtendsValue(raw: string): ExtendsSource {
-  if (raw.startsWith('npm:')) return { kind: 'npm', packageName: raw.slice(4) };
-  if (raw.startsWith('https://') || raw.startsWith('http://')) return { kind: 'url', url: raw };
-  return { kind: 'file', path: raw };
-}
-
-export function resolveFileExtends(
-  configPath: string,
-  extendsPath: string,
-): Record<string, unknown> | null {
-  const dir = dirname(resolve(configPath));
-  const abs = resolve(dir, extendsPath);
-  if (!existsSync(abs)) return null;
-  try {
-    return JSON.parse(readFileSync(abs, 'utf8')) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-export function resolveNpmExtends(
-  root: string,
-  packageName: string,
-): Record<string, unknown> | null {
-  const candidates = ['monograph.json', 'monograph.config.json', '.monographrc.json'];
-  let dir = root;
-  while (true) {
-    const pkgDir = resolve(dir, 'node_modules', packageName);
-    if (existsSync(pkgDir)) {
-      for (const name of candidates) {
-        const path = resolve(pkgDir, name);
-        if (existsSync(path)) {
-          try {
-            return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
-          } catch { return null; }
-        }
-      }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
-export function mergeConfigs(
-  base: Record<string, unknown>,
-  override: Record<string, unknown>,
-): Record<string, unknown> {
-  const result = { ...base };
-  for (const [key, val] of Object.entries(override)) {
-    if (key === 'extends') continue;
-    if (Array.isArray(val) && Array.isArray(result[key])) {
-      result[key] = [...(result[key] as unknown[]), ...val];
-    } else if (typeof val === 'object' && val !== null && typeof result[key] === 'object' && result[key] !== null) {
-      result[key] = mergeConfigs(result[key] as Record<string, unknown>, val as Record<string, unknown>);
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-
-export async function resolveConfigExtends(
-  config: Record<string, unknown>,
-  configPath: string,
-  root: string,
-  depth = 0,
-): Promise<Record<string, unknown>> {
-  if (depth > 10) return config;
-  const extendsVal = config['extends'];
-  if (!extendsVal) return config;
-  const sources = Array.isArray(extendsVal) ? extendsVal as string[] : [extendsVal as string];
-  let resolved = { ...config };
-  delete resolved['extends'];
-  for (const src of sources) {
-    const parsed = parseExtendsValue(src);
-    let base: Record<string, unknown> | null = null;
-    if (parsed.kind === 'file') base = resolveFileExtends(configPath, parsed.path);
-    else if (parsed.kind === 'npm') base = resolveNpmExtends(root, parsed.packageName);
-    if (base) {
-      const resolvedBase = await resolveConfigExtends(base, configPath, root, depth + 1);
-      resolved = mergeConfigs(resolvedBase, resolved);
-    }
-  }
-  return resolved;
-}

package/src/config/rules.ts

@@ -1,70 +0,0 @@
-// Per-issue-type severity configuration for all 19 fallow issue categories.
-
-export type Severity = 'error' | 'warn' | 'off';
-
-export interface RulesConfig {
-  unusedFiles: Severity;
-  unusedExports: Severity;
-  unusedTypes: Severity;
-  privateTypeLeaks: Severity;
-  unusedDependencies: Severity;
-  unusedDevDependencies: Severity;
-  unusedOptionalDependencies: Severity;
-  unusedEnumMembers: Severity;
-  unusedClassMembers: Severity;
-  unresolvedImports: Severity;
-  unlistedDependencies: Severity;
-  duplicateExports: Severity;
-  typeOnlyDependencies: Severity;
-  testOnlyDependencies: Severity;
-  circularDependencies: Severity;
-  boundaryViolation: Severity;
-  coverageGaps: Severity;
-  featureFlags: Severity;
-  staleSuppressions: Severity;
-}
-
-export type PartialRulesConfig = Partial<RulesConfig>;
-
-export const DEFAULT_RULES_CONFIG: RulesConfig = {
-  unusedFiles: 'error',
-  unusedExports: 'error',
-  unusedTypes: 'error',
-  privateTypeLeaks: 'error',
-  unusedDependencies: 'error',
-  unusedDevDependencies: 'warn',
-  unusedOptionalDependencies: 'warn',
-  unusedEnumMembers: 'error',
-  unusedClassMembers: 'warn',
-  unresolvedImports: 'error',
-  unlistedDependencies: 'error',
-  duplicateExports: 'warn',
-  typeOnlyDependencies: 'warn',
-  testOnlyDependencies: 'warn',
-  circularDependencies: 'warn',
-  boundaryViolation: 'error',
-  coverageGaps: 'warn',
-  featureFlags: 'warn',
-  staleSuppressions: 'warn',
-};
-
-export function mergeRulesConfig(base: RulesConfig, partial: PartialRulesConfig): RulesConfig {
-  return { ...base, ...partial };
-}
-
-export function severityToExitCode(severity: Severity): number {
-  return severity === 'error' ? 1 : 0;
-}
-
-export function issueSeverityFor(rules: RulesConfig, issueKind: keyof RulesConfig): Severity {
-  return rules[issueKind];
-}
-
-export const ALL_ISSUE_KINDS: Array<keyof RulesConfig> = [
-  'unusedFiles', 'unusedExports', 'unusedTypes', 'privateTypeLeaks',
-  'unusedDependencies', 'unusedDevDependencies', 'unusedOptionalDependencies',
-  'unusedEnumMembers', 'unusedClassMembers', 'unresolvedImports',
-  'unlistedDependencies', 'duplicateExports', 'typeOnlyDependencies',
-  'testOnlyDependencies', 'circularDependencies', 'boundaryViolation',
-  'coverageGaps', 'featureFlags', 'staleSuppressions',
-];