gemini-cli / eslint.config.js

Add files using upload-large-folder tool

c6d079d verified about 1 month ago

13.2 kB

/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

import eslint from '@eslint/js';
import tseslint from 'typescript-eslint';
import reactPlugin from 'eslint-plugin-react';
import reactHooks from 'eslint-plugin-react-hooks';
import prettierConfig from 'eslint-config-prettier';
import importPlugin from 'eslint-plugin-import';
import vitest from '@vitest/eslint-plugin';
import globals from 'globals';
import headers from 'eslint-plugin-headers';
import path from 'node:path';
import url from 'node:url';

// --- ESM way to get __dirname ---
const __filename = url.fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
// --- ---

// Determine the monorepo root (assuming eslint.config.js is at the root)
const projectRoot = __dirname;
const currentYear = new Date().getFullYear();

const commonRestrictedSyntaxRules = [
  {
    selector: 'CallExpression[callee.name="require"]',
    message: 'Avoid using require(). Use ES6 imports instead.',
  },
  {
    selector: 'ThrowStatement > Literal:not([value=/^\\w+Error:/])',
    message:
      'Do not throw string literals or non-Error objects. Throw new Error("...") instead.',
  },
  {
    selector:
      'UnaryExpression[operator="typeof"] > MemberExpression[computed=true][property.type="Literal"]',
    message:
      'Do not use typeof to check object properties. Define a TypeScript interface and a type guard function instead.',
  },
  {
    selector: 'CatchClause > Identifier[name=/^_/]',
    message:
      'Do not use underscored identifiers in catch blocks. If the error is unused, use "catch {}". If it is used, remove the underscore.',
  },
];

export default tseslint.config(
  {
    // Global ignores
    ignores: [
      '**/node_modules/**',
      'eslint.config.js',
      '**/coverage/**',
      'packages/**/dist/**',
      'tools/**/dist/**',
      'bundle/**',
      'package/bundle/**',
      '.integration-tests/**',
      'dist/**',
      'evals/**',
      'packages/test-utils/**',
      '.gemini/**',
      '**/*.d.ts',
    ],
  },
  eslint.configs.recommended,
  ...tseslint.configs.recommended,
  reactHooks.configs['recommended-latest'],
  reactPlugin.configs.flat.recommended,
  reactPlugin.configs.flat['jsx-runtime'], // Add this if you are using React 17+
  {
    // Settings for eslint-plugin-react
    settings: {
      react: {
        version: 'detect',
      },
    },
  },
  {
    // Rules for packages/*/src and tools/caretaker-agent (TS/TSX)
    files: ['packages/*/src/**/*.{ts,tsx}', 'tools/caretaker-agent/**/*.{ts,tsx}'],
    plugins: {
      import: importPlugin,
    },
    settings: {
      'import/resolver': {
        node: true,
      },
    },
    languageOptions: {
      parser: tseslint.parser,
      parserOptions: {
        projectService: true,
        tsconfigRootDir: projectRoot,
      },
      globals: {
        ...globals.node,
        ...globals.es2021,
      },
    },
    rules: {
      ...importPlugin.configs.recommended.rules,
      ...importPlugin.configs.typescript.rules,
      'import/no-default-export': 'warn',
      'import/no-unresolved': 'off',
      'import/no-duplicates': 'error',
      // General Best Practice Rules (subset adapted for flat config)
      '@typescript-eslint/array-type': ['error', { default: 'array-simple' }],
      'arrow-body-style': ['error', 'as-needed'],
      curly: ['error', 'multi-line'],
      eqeqeq: ['error', 'always', { null: 'ignore' }],
      '@typescript-eslint/consistent-type-assertions': [
        'error',
        { assertionStyle: 'as' },
      ],
      '@typescript-eslint/explicit-member-accessibility': [
        'error',
        { accessibility: 'no-public' },
      ],
      '@typescript-eslint/no-explicit-any': 'error',
      '@typescript-eslint/no-inferrable-types': [
        'error',
        { ignoreParameters: true, ignoreProperties: true },
      ],
      '@typescript-eslint/consistent-type-imports': [
        'error',
        { disallowTypeAnnotations: false },
      ],
      '@typescript-eslint/no-namespace': ['error', { allowDeclarations: true }],
      '@typescript-eslint/no-unused-vars': [
        'error',
        {
          argsIgnorePattern: '^_',
          varsIgnorePattern: '^_',
          caughtErrors: 'all',
        },
      ],
      // Prevent async errors from bypassing catch handlers
      '@typescript-eslint/return-await': ['error', 'in-try-catch'],
      'import/no-internal-modules': 'off',
      'import/no-relative-packages': 'error',
      'no-cond-assign': 'error',
      'no-debugger': 'error',
      'no-duplicate-case': 'error',
      'no-restricted-syntax': ['error', ...commonRestrictedSyntaxRules],
      'no-unsafe-finally': 'error',
      'no-unused-expressions': 'off', // Disable base rule
      '@typescript-eslint/no-unused-expressions': [
        // Enable TS version
        'error',
        { allowShortCircuit: true, allowTernary: true },
      ],
      'no-var': 'error',
      'object-shorthand': 'error',
      'one-var': ['error', 'never'],
      'prefer-arrow-callback': 'error',
      'prefer-const': ['error', { destructuring: 'all' }],
      radix: 'error',
      'no-console': 'error',
      'default-case': 'error',
      '@typescript-eslint/await-thenable': ['error'],
      '@typescript-eslint/no-floating-promises': ['error'],
      '@typescript-eslint/no-unnecessary-type-assertion': ['error'],
      '@typescript-eslint/no-misused-spread': ['error'],
      'no-restricted-imports': [
        'error',
        {
          paths: [
            {
              name: 'node:os',
              importNames: ['homedir', 'tmpdir'],
              message:
                'Please use the helpers from @google/gemini-cli-core instead of node:os homedir()/tmpdir() to ensure strict environment isolation.',
            },
            {
              name: 'os',
              importNames: ['homedir', 'tmpdir'],
              message:
                'Please use the helpers from @google/gemini-cli-core instead of os homedir()/tmpdir() to ensure strict environment isolation.',
            },
          ],
        },
      ],
    },
  },
  {
    // API Response Optionality enforcement for Code Assist
    files: ['packages/core/src/code_assist/**/*.{ts,tsx}'],
    rules: {
      'no-restricted-syntax': [
        'error',
        ...commonRestrictedSyntaxRules,
        {
          selector:
            'TSInterfaceDeclaration[id.name=/.+Response$/] TSPropertySignature:not([optional=true])',
          message:
            'All fields in API response interfaces (*Response) must be marked as optional (?) to prevent developers from accidentally assuming a field will always be present based on current backend behavior.',
        },
        {
          selector:
            'TSTypeAliasDeclaration[id.name=/.+Response$/] TSPropertySignature:not([optional=true])',
          message:
            'All fields in API response types (*Response) must be marked as optional (?) to prevent developers from accidentally assuming a field will always be present based on current backend behavior.',
        },
      ],
    },
  },
  {
    // Rules that only apply to product code
    files: ['packages/*/src/**/*.{ts,tsx}'],
    ignores: ['**/*.test.ts', '**/*.test.tsx', 'packages/*/src/test-utils/**'],
    rules: {
      '@typescript-eslint/no-unsafe-type-assertion': 'error',
      '@typescript-eslint/no-unsafe-assignment': 'error',
      '@typescript-eslint/no-unsafe-return': 'error',
      'no-restricted-syntax': [
        'error',
        ...commonRestrictedSyntaxRules,
        {
          selector:
            'CallExpression[callee.object.name="Object"][callee.property.name="create"]',
          message:
            'Avoid using Object.create() in product code. Use object spread {...obj}, explicit class instantiation, structuredClone(), or copy constructors instead.',
        },
        {
          selector: 'Identifier[name="Reflect"]',
          message:
            'Avoid using Reflect namespace in product code. Do not use reflection to make copies. Instead, use explicit object copying or cloning (structuredClone() for values, new instance/clone function for classes).',
        },
      ],
    },
  },
  {
    // Allow os.homedir() in tests and paths.ts where it is used to implement the helper
    files: [
      '**/*.test.ts',
      '**/*.test.tsx',
      'packages/core/src/utils/paths.ts',
      'packages/test-utils/src/**/*.ts',
      'scripts/**/*.js',
    ],
    rules: {
      'no-restricted-imports': 'off',
    },
  },
  {
    // Prevent self-imports in packages
    files: ['packages/core/src/**/*.{ts,tsx}'],
    rules: {
      'no-restricted-imports': [
        'error',
        {
          name: '@google/gemini-cli-core',
          message: 'Please use relative imports within the @google/gemini-cli-core package.',
        },
      ],
    },
  },
  {
    files: ['packages/cli/src/**/*.{ts,tsx}'],
    rules: {
      'no-restricted-imports': [
        'error',
        {
          name: '@google/gemini-cli',
          message: 'Please use relative imports within the @google/gemini-cli package.',
        },
      ],
    },
  },
  {
    files: ['packages/sdk/src/**/*.{ts,tsx}'],
    rules: {
      'no-restricted-imports': [
        'error',
        {
          name: '@google/gemini-cli-sdk',
          message: 'Please use relative imports within the @google/gemini-cli-sdk package.',
        },
      ],
    },
  },
  {
    files: ['packages/*/src/**/*.test.{ts,tsx}', 'tools/**/*.test.ts'],
    plugins: {
      vitest,
    },
    rules: {
      ...vitest.configs.recommended.rules,
      'vitest/expect-expect': 'off',
      'vitest/no-commented-out-tests': 'off',
      'no-restricted-syntax': ['error', ...commonRestrictedSyntaxRules],
    },
  },
  {
    files: ['./**/*.{tsx,ts,js,cjs}'],
    plugins: {
      headers,
      import: importPlugin,
    },
    rules: {
      'headers/header-format': [
        'error',
        {
          source: 'string',
          content: [
            '@license',
            'Copyright (year) Google LLC',
            'SPDX-License-Identifier: Apache-2.0',
          ].join('\n'),
          patterns: {
            year: {
              pattern: `202[5-${currentYear.toString().slice(-1)}]`,
              defaultValue: currentYear.toString(),
            },
          },
        },
      ],
      'import/enforce-node-protocol-usage': ['error', 'always'],
    },
  },
  {
    files: [
      './scripts/**/*.js',
      'packages/*/scripts/**/*.js',
      'esbuild.config.js',
      'packages/core/scripts/**/*.{js,mjs}',
    ],
    languageOptions: {
      globals: {
        ...globals.node,
        process: 'readonly',
        console: 'readonly',
      },
    },
    rules: {
      '@typescript-eslint/no-unused-vars': [
        'error',
        {
          argsIgnorePattern: '^_',
          varsIgnorePattern: '^_',
          caughtErrors: 'all',
        },
      ],
    },
  },
  {
    files: ['**/*.cjs'],
    languageOptions: {
      sourceType: 'commonjs',
      globals: {
        ...globals.node,
      },
    },
    rules: {
      'no-restricted-syntax': 'off',
      'no-console': 'off',
      'no-empty': 'off',
      'no-redeclare': 'off',
      '@typescript-eslint/no-require-imports': 'off',
      '@typescript-eslint/no-unused-vars': [
        'error',
        {
          argsIgnorePattern: '^_',
          varsIgnorePattern: '^_',
          caughtErrors: 'all',
        },
      ],
    },
  },
  {
    files: ['packages/vscode-ide-companion/esbuild.js'],
    languageOptions: {
      globals: {
        ...globals.node,
        process: 'readonly',
        console: 'readonly',
      },
    },
    rules: {
      'no-restricted-syntax': 'off',
      '@typescript-eslint/no-require-imports': 'off',
    },
  },
  // Examples should have access to standard globals like fetch
  {
    files: ['packages/cli/src/commands/extensions/examples/**/*.js'],
    languageOptions: {
      globals: {
        ...globals.node,
        fetch: 'readonly',
      },
    },
  },
  // extra settings for scripts that we run directly with node
  {
    files: ['packages/vscode-ide-companion/scripts/**/*.js'],
    languageOptions: {
      globals: {
        ...globals.node,
        process: 'readonly',
        console: 'readonly',
      },
    },
    rules: {
      'no-restricted-syntax': 'off',
      '@typescript-eslint/no-require-imports': 'off',
    },
  },
  // Allow console logging for backend services (Cloud Logging)
  {
    files: ['tools/**/*.ts', 'tools/**/*.test.ts'],
    rules: {
      'no-console': 'off',
    },
  },
  // Prettier config must be last
  prettierConfig,
  // extra settings for scripts that we run directly with node
  {
    files: ['./integration-tests/**/*.js'],
    languageOptions: {
      globals: {
        ...globals.node,
        process: 'readonly',
        console: 'readonly',
      },
    },
    rules: {
      '@typescript-eslint/no-unused-vars': [
        'error',
        {
          argsIgnorePattern: '^_',
          varsIgnorePattern: '^_',
          caughtErrors: 'all',
        },
      ],
    },
  },
);

	/**
	* @license
	* Copyright 2025 Google LLC
	* SPDX-License-Identifier: Apache-2.0
	*/

	import eslint from '@eslint/js';
	import tseslint from 'typescript-eslint';
	import reactPlugin from 'eslint-plugin-react';
	import reactHooks from 'eslint-plugin-react-hooks';
	import prettierConfig from 'eslint-config-prettier';
	import importPlugin from 'eslint-plugin-import';
	import vitest from '@vitest/eslint-plugin';
	import globals from 'globals';
	import headers from 'eslint-plugin-headers';
	import path from 'node:path';
	import url from 'node:url';

	// --- ESM way to get __dirname ---
	const __filename = url.fileURLToPath(import.meta.url);
	const __dirname = path.dirname(__filename);
	// --- ---

	// Determine the monorepo root (assuming eslint.config.js is at the root)
	const projectRoot = __dirname;
	const currentYear = new Date().getFullYear();

	const commonRestrictedSyntaxRules = [
	{
	selector: 'CallExpression[callee.name="require"]',
	message: 'Avoid using require(). Use ES6 imports instead.',
	},
	{
	selector: 'ThrowStatement > Literal:not([value=/^\\w+Error:/])',
	message:
	'Do not throw string literals or non-Error objects. Throw new Error("...") instead.',
	},
	{
	selector:
	'UnaryExpression[operator="typeof"] > MemberExpression[computed=true][property.type="Literal"]',
	message:
	'Do not use typeof to check object properties. Define a TypeScript interface and a type guard function instead.',
	},
	{
	selector: 'CatchClause > Identifier[name=/^_/]',
	message:
	'Do not use underscored identifiers in catch blocks. If the error is unused, use "catch {}". If it is used, remove the underscore.',
	},
	];

	export default tseslint.config(
	{
	// Global ignores
	ignores: [
	'/node_modules/',
	'eslint.config.js',
	'/coverage/',
	'packages//dist/',
	'tools//dist/',
	'bundle/**',
	'package/bundle/**',
	'.integration-tests/**',
	'dist/**',
	'evals/**',
	'packages/test-utils/**',
	'.gemini/**',
	'*/.d.ts',
	],
	},
	eslint.configs.recommended,
	...tseslint.configs.recommended,
	reactHooks.configs['recommended-latest'],
	reactPlugin.configs.flat.recommended,
	reactPlugin.configs.flat['jsx-runtime'], // Add this if you are using React 17+
	{
	// Settings for eslint-plugin-react
	settings: {
	react: {
	version: 'detect',
	},
	},
	},
	{
	// Rules for packages/*/src and tools/caretaker-agent (TS/TSX)
	files: ['packages//src//.{ts,tsx}', 'tools/caretaker-agent/*/.{ts,tsx}'],
	plugins: {
	import: importPlugin,
	},
	settings: {
	'import/resolver': {
	node: true,
	},
	},
	languageOptions: {
	parser: tseslint.parser,
	parserOptions: {
	projectService: true,
	tsconfigRootDir: projectRoot,
	},
	globals: {
	...globals.node,
	...globals.es2021,
	},
	},
	rules: {
	...importPlugin.configs.recommended.rules,
	...importPlugin.configs.typescript.rules,
	'import/no-default-export': 'warn',
	'import/no-unresolved': 'off',
	'import/no-duplicates': 'error',
	// General Best Practice Rules (subset adapted for flat config)
	'@typescript-eslint/array-type': ['error', { default: 'array-simple' }],
	'arrow-body-style': ['error', 'as-needed'],
	curly: ['error', 'multi-line'],
	eqeqeq: ['error', 'always', { null: 'ignore' }],
	'@typescript-eslint/consistent-type-assertions': [
	'error',
	{ assertionStyle: 'as' },
	],
	'@typescript-eslint/explicit-member-accessibility': [
	'error',
	{ accessibility: 'no-public' },
	],
	'@typescript-eslint/no-explicit-any': 'error',
	'@typescript-eslint/no-inferrable-types': [
	'error',
	{ ignoreParameters: true, ignoreProperties: true },
	],
	'@typescript-eslint/consistent-type-imports': [
	'error',
	{ disallowTypeAnnotations: false },
	],
	'@typescript-eslint/no-namespace': ['error', { allowDeclarations: true }],
	'@typescript-eslint/no-unused-vars': [
	'error',
	{
	argsIgnorePattern: '^_',
	varsIgnorePattern: '^_',
	caughtErrors: 'all',
	},
	],
	// Prevent async errors from bypassing catch handlers
	'@typescript-eslint/return-await': ['error', 'in-try-catch'],
	'import/no-internal-modules': 'off',
	'import/no-relative-packages': 'error',
	'no-cond-assign': 'error',
	'no-debugger': 'error',
	'no-duplicate-case': 'error',
	'no-restricted-syntax': ['error', ...commonRestrictedSyntaxRules],
	'no-unsafe-finally': 'error',
	'no-unused-expressions': 'off', // Disable base rule
	'@typescript-eslint/no-unused-expressions': [
	// Enable TS version
	'error',
	{ allowShortCircuit: true, allowTernary: true },
	],
	'no-var': 'error',
	'object-shorthand': 'error',
	'one-var': ['error', 'never'],
	'prefer-arrow-callback': 'error',
	'prefer-const': ['error', { destructuring: 'all' }],
	radix: 'error',
	'no-console': 'error',
	'default-case': 'error',
	'@typescript-eslint/await-thenable': ['error'],
	'@typescript-eslint/no-floating-promises': ['error'],
	'@typescript-eslint/no-unnecessary-type-assertion': ['error'],
	'@typescript-eslint/no-misused-spread': ['error'],
	'no-restricted-imports': [
	'error',
	{
	paths: [
	{
	name: 'node:os',
	importNames: ['homedir', 'tmpdir'],
	message:
	'Please use the helpers from @google/gemini-cli-core instead of node:os homedir()/tmpdir() to ensure strict environment isolation.',
	},
	{
	name: 'os',
	importNames: ['homedir', 'tmpdir'],
	message:
	'Please use the helpers from @google/gemini-cli-core instead of os homedir()/tmpdir() to ensure strict environment isolation.',
	},
	],
	},
	],
	},
	},
	{
	// API Response Optionality enforcement for Code Assist
	files: ['packages/core/src/code_assist/*/.{ts,tsx}'],
	rules: {
	'no-restricted-syntax': [
	'error',
	...commonRestrictedSyntaxRules,
	{
	selector:
	'TSInterfaceDeclaration[id.name=/.+Response$/] TSPropertySignature:not([optional=true])',
	message:
	'All fields in API response interfaces (*Response) must be marked as optional (?) to prevent developers from accidentally assuming a field will always be present based on current backend behavior.',
	},
	{
	selector:
	'TSTypeAliasDeclaration[id.name=/.+Response$/] TSPropertySignature:not([optional=true])',
	message:
	'All fields in API response types (*Response) must be marked as optional (?) to prevent developers from accidentally assuming a field will always be present based on current backend behavior.',
	},
	],
	},
	},
	{
	// Rules that only apply to product code
	files: ['packages//src//.{ts,tsx}'],
	ignores: ['*/.test.ts', '*/.test.tsx', 'packages//src/test-utils/*'],
	rules: {
	'@typescript-eslint/no-unsafe-type-assertion': 'error',
	'@typescript-eslint/no-unsafe-assignment': 'error',
	'@typescript-eslint/no-unsafe-return': 'error',
	'no-restricted-syntax': [
	'error',
	...commonRestrictedSyntaxRules,
	{
	selector:
	'CallExpression[callee.object.name="Object"][callee.property.name="create"]',
	message:
	'Avoid using Object.create() in product code. Use object spread {...obj}, explicit class instantiation, structuredClone(), or copy constructors instead.',
	},
	{
	selector: 'Identifier[name="Reflect"]',
	message:
	'Avoid using Reflect namespace in product code. Do not use reflection to make copies. Instead, use explicit object copying or cloning (structuredClone() for values, new instance/clone function for classes).',
	},
	],
	},
	},
	{
	// Allow os.homedir() in tests and paths.ts where it is used to implement the helper
	files: [
	'*/.test.ts',
	'*/.test.tsx',
	'packages/core/src/utils/paths.ts',
	'packages/test-utils/src/*/.ts',
	'scripts/*/.js',
	],
	rules: {
	'no-restricted-imports': 'off',
	},
	},
	{
	// Prevent self-imports in packages
	files: ['packages/core/src/*/.{ts,tsx}'],
	rules: {
	'no-restricted-imports': [
	'error',
	{
	name: '@google/gemini-cli-core',
	message: 'Please use relative imports within the @google/gemini-cli-core package.',
	},
	],
	},
	},
	{
	files: ['packages/cli/src/*/.{ts,tsx}'],
	rules: {
	'no-restricted-imports': [
	'error',
	{
	name: '@google/gemini-cli',
	message: 'Please use relative imports within the @google/gemini-cli package.',
	},
	],
	},
	},
	{
	files: ['packages/sdk/src/*/.{ts,tsx}'],
	rules: {
	'no-restricted-imports': [
	'error',
	{
	name: '@google/gemini-cli-sdk',
	message: 'Please use relative imports within the @google/gemini-cli-sdk package.',
	},
	],
	},
	},
	{
	files: ['packages//src//.test.{ts,tsx}', 'tools/*/.test.ts'],
	plugins: {
	vitest,
	},
	rules: {
	...vitest.configs.recommended.rules,
	'vitest/expect-expect': 'off',
	'vitest/no-commented-out-tests': 'off',
	'no-restricted-syntax': ['error', ...commonRestrictedSyntaxRules],
	},
	},
	{
	files: ['./*/.{tsx,ts,js,cjs}'],
	plugins: {
	headers,
	import: importPlugin,
	},
	rules: {
	'headers/header-format': [
	'error',
	{
	source: 'string',
	content: [
	'@license',
	'Copyright (year) Google LLC',
	'SPDX-License-Identifier: Apache-2.0',
	].join('\n'),
	patterns: {
	year: {
	pattern: `202[5-${currentYear.toString().slice(-1)}]`,
	defaultValue: currentYear.toString(),
	},
	},
	},
	],
	'import/enforce-node-protocol-usage': ['error', 'always'],
	},
	},
	{
	files: [
	'./scripts/*/.js',
	'packages//scripts//.js',
	'esbuild.config.js',
	'packages/core/scripts/*/.{js,mjs}',
	],
	languageOptions: {
	globals: {
	...globals.node,
	process: 'readonly',
	console: 'readonly',
	},
	},
	rules: {
	'@typescript-eslint/no-unused-vars': [
	'error',
	{
	argsIgnorePattern: '^_',
	varsIgnorePattern: '^_',
	caughtErrors: 'all',
	},
	],
	},
	},
	{
	files: ['*/.cjs'],
	languageOptions: {
	sourceType: 'commonjs',
	globals: {
	...globals.node,
	},
	},
	rules: {
	'no-restricted-syntax': 'off',
	'no-console': 'off',
	'no-empty': 'off',
	'no-redeclare': 'off',
	'@typescript-eslint/no-require-imports': 'off',
	'@typescript-eslint/no-unused-vars': [
	'error',
	{
	argsIgnorePattern: '^_',
	varsIgnorePattern: '^_',
	caughtErrors: 'all',
	},
	],
	},
	},
	{
	files: ['packages/vscode-ide-companion/esbuild.js'],
	languageOptions: {
	globals: {
	...globals.node,
	process: 'readonly',
	console: 'readonly',
	},
	},
	rules: {
	'no-restricted-syntax': 'off',
	'@typescript-eslint/no-require-imports': 'off',
	},
	},
	// Examples should have access to standard globals like fetch
	{
	files: ['packages/cli/src/commands/extensions/examples/*/.js'],
	languageOptions: {
	globals: {
	...globals.node,
	fetch: 'readonly',
	},
	},
	},
	// extra settings for scripts that we run directly with node
	{
	files: ['packages/vscode-ide-companion/scripts/*/.js'],
	languageOptions: {
	globals: {
	...globals.node,
	process: 'readonly',
	console: 'readonly',
	},
	},
	rules: {
	'no-restricted-syntax': 'off',
	'@typescript-eslint/no-require-imports': 'off',
	},
	},
	// Allow console logging for backend services (Cloud Logging)
	{
	files: ['tools/*/.ts', 'tools/*/.test.ts'],
	rules: {
	'no-console': 'off',
	},
	},
	// Prettier config must be last
	prettierConfig,
	// extra settings for scripts that we run directly with node
	{
	files: ['./integration-tests/*/.js'],
	languageOptions: {
	globals: {
	...globals.node,
	process: 'readonly',
	console: 'readonly',
	},
	},
	rules: {
	'@typescript-eslint/no-unused-vars': [
	'error',
	{
	argsIgnorePattern: '^_',
	varsIgnorePattern: '^_',
	caughtErrors: 'all',
	},
	],
	},
	},
	);