@monoes/monograph 1.1.0 → 1.2.0

package/src/config/plugins/builtin.ts

@@ -0,0 +1,411 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,102 @@
+// 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

@@ -0,0 +1,70 @@
+// 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',
+];