pi-python-helper 0.1.0 → 0.2.0

package/src/project/conformance.ts

@@ -50,6 +50,12 @@ export interface ConformanceReport {
     installedScanned: boolean;
     projectInstalled: boolean | null;
     projectEditable: boolean | null;
+    /**
+     * False when the root project is a `virtual` lock source, which uv creates
+     * for a project without a `[build-system]` table. Such a project is never
+     * installed into `.venv`, so its absence is expected rather than drift.
+     */
+    projectInstallable: boolean | null;
   };
   counts: {
     lockPackages: number;
@@ -59,6 +65,11 @@ export interface ConformanceReport {
     /** Locked entries that are conditional for this platform and correctly absent. */
     conditional: number;
     untracked: number;
+    /**
+     * Normalized names that uv.lock pins more than once (a marker split, such as
+     * `argon2-cffi-bindings` at 21.2.0 for Python 3.14 and 25.1.0 below it).
+     */
+    markerSplitNames: number;
   };
   findings: ConformanceFinding[];
   warnings: Diagnostic[];
@@ -147,6 +158,7 @@ export function compareInstalledConformance(input: ConformanceInput): Conformanc
     installedScanned: venvPresent,
     projectInstalled: null as boolean | null,
     projectEditable: null as boolean | null,
+    projectInstallable: null as boolean | null,
   };
   const counts = {
     lockPackages: lock?.packages.length ?? 0,
@@ -155,6 +167,7 @@ export function compareInstalledConformance(input: ConformanceInput): Conformanc
     missing: 0,
     conditional: 0,
     untracked: 0,
+    markerSplitNames: 0,
   };
 
   for (const message of installed?.warnings ?? []) {
@@ -189,51 +202,83 @@ export function compareInstalledConformance(input: ConformanceInput): Conformanc
   const lockByNormalized = new Map(lock.packages.map((entry) => [entry.normalized, entry]));
   const required = requiredInstalledNames(lock, new Set(installedByNormalized.keys()), input);
   const conditionalAbsent: string[] = [];
+  const markerSplitNames: string[] = [];
+  const virtualRoots: string[] = [];
 
+  // uv writes one lock entry per marker branch, so a name can appear several
+  // times with different versions. Comparing a single arbitrary entry reported a
+  // version mismatch on a correctly synced environment (21.2.0 is locked for
+  // Python 3.14 while a 3.12 environment rightly has 25.1.0).
+  const variantsByNormalized = new Map<string, LockPackage[]>();
   for (const entry of lock.packages) {
-    const actual = installedByNormalized.get(entry.normalized);
-    const localProject = isLocalProjectEntry(entry);
-    const rootProject = isRootProjectEntry(entry, projectName);
+    const variants = variantsByNormalized.get(entry.normalized);
+    if (variants) variants.push(entry);
+    else variantsByNormalized.set(entry.normalized, [entry]);
+  }
+
+  for (const [normalized, variants] of variantsByNormalized) {
+    const primary = variants[0];
+    const actual = installedByNormalized.get(normalized);
+    const localProject = variants.some((variant) => isLocalProjectEntry(variant));
+    const rootProject = variants.some((variant) => isRootProjectEntry(variant, projectName));
+    if (variants.length > 1) {
+      counts.markerSplitNames += 1;
+      markerSplitNames.push(primary.name);
+    }
 
     if (!actual) {
       if (localProject) {
+        if (rootProject && variants.some((variant) => variant.source === 'virtual')) {
+          // Without a [build-system] uv records the project as a virtual source
+          // and never installs it; its absence from .venv is not drift.
+          checks.projectInstalled = false;
+          checks.projectInstallable = false;
+          virtualRoots.push(primary.name);
+          continue;
+        }
         counts.missing += 1;
         if (rootProject) checks.projectInstalled = false;
         findings.push({
           code: 'PROJECT_NOT_INSTALLED',
-          name: entry.name,
-          expected: entry.version ?? undefined,
+          name: primary.name,
+          expected: primary.version ?? undefined,
           message: rootProject
-            ? `uv.lock records "${entry.name}" as an editable install, but it is absent from .venv. The project is not importable and no test can exercise it.`
-            : `uv.lock records the local project "${entry.name}" as an editable install, but it is absent from .venv.`,
+            ? `uv.lock records "${primary.name}" as an editable install, but it is absent from .venv. The project is not importable and no test can exercise it.`
+            : `uv.lock records the local project "${primary.name}" as an editable install, but it is absent from .venv.`,
         });
-      } else if (required.has(entry.normalized)) {
+      } else if (required.has(normalized)) {
         counts.missing += 1;
         findings.push({
           code: 'INSTALLED_PACKAGE_MISSING',
-          name: entry.name,
-          expected: entry.version ?? undefined,
-          message: `"${entry.name}" is locked and required unconditionally, but it is not installed in .venv.`,
+          name: primary.name,
+          expected: primary.version ?? undefined,
+          message: `"${primary.name}" is locked and required unconditionally, but it is not installed in .venv.`,
         });
       } else {
         // Guarded by a platform or version marker, so this platform rightly omits it.
-        counts.conditional += 1;
-        conditionalAbsent.push(`${entry.name}@${entry.version ?? '?'}`);
+        counts.conditional += variants.length;
+        for (const variant of variants) {
+          const label = `${primary.name}@${variant.version ?? '?'}`;
+          if (!conditionalAbsent.includes(label)) conditionalAbsent.push(label);
+        }
       }
       continue;
     }
 
     if (localProject) {
-      if (rootProject) checks.projectInstalled = true;
+      if (rootProject) {
+        checks.projectInstalled = true;
+        checks.projectInstallable = true;
+      }
       if (actual.source !== 'editable') {
         if (rootProject) checks.projectEditable = false;
         findings.push({
           code: 'PROJECT_INSTALLED_NOT_EDITABLE',
-          name: entry.name,
+          name: primary.name,
           actual: actual.version,
           message: rootProject
-            ? `"${entry.name}" is installed from a materialised copy instead of an editable link, so tests would import a stale snapshot of the sources.`
-            : `The local project "${entry.name}" is installed from a materialised copy instead of an editable link.`,
+            ? `"${primary.name}" is installed from a materialised copy instead of an editable link, so tests would import a stale snapshot of the sources.`
+            : `The local project "${primary.name}" is installed from a materialised copy instead of an editable link.`,
         });
       } else if (rootProject) {
         checks.projectEditable = true;
@@ -243,16 +288,31 @@ export function compareInstalledConformance(input: ConformanceInput): Conformanc
       continue;
     }
 
-    if (entry.version && actual.version !== entry.version) {
-      counts.mismatched += 1;
-      findings.push({
-        code: 'INSTALLED_VERSION_MISMATCH',
-        name: entry.name,
-        expected: entry.version,
-        actual: actual.version,
-        message: `"${entry.name}" is locked at ${entry.version} but ${actual.version} is installed in .venv.`,
+    // Matching any locked variant is positive proof the environment agrees with
+    // the lockfile for the markers that apply here.
+    if (variants.some((variant) => variant.version === actual.version)) continue;
+
+    const versions = variants.map((variant) => variant.version).filter((value) => value !== null);
+    if (versions.length === 0) {
+      notes.push({
+        code: 'LOCKED_VERSION_UNKNOWN',
+        message: `uv.lock records "${primary.name}" without a version, so the installed ${actual.version} could not be compared.`,
+        severity: 'info',
       });
+      continue;
     }
+
+    counts.mismatched += 1;
+    findings.push({
+      code: 'INSTALLED_VERSION_MISMATCH',
+      name: primary.name,
+      expected: versions.join(' | '),
+      actual: actual.version,
+      message:
+        versions.length > 1
+          ? `"${primary.name}" is locked at ${versions.join(' or ')} (marker-dependent) but ${actual.version} is installed in .venv, which matches none of them.`
+          : `"${primary.name}" is locked at ${versions[0]} but ${actual.version} is installed in .venv.`,
+    });
   }
 
   const untrackedCandidates = (installed?.distributions ?? []).filter(
@@ -284,6 +344,22 @@ export function compareInstalledConformance(input: ConformanceInput): Conformanc
     }
   }
 
+  if (markerSplitNames.length > 0) {
+    notes.push({
+      code: 'MARKER_SPLIT_LOCK_ENTRIES',
+      message: `${markerSplitNames.length} distribution(s) are locked more than once because uv splits them by marker (${markerSplitNames.slice(0, 5).join(', ')}${markerSplitNames.length > 5 ? ', …' : ''}); the installed version is compared against every variant and matches when it equals any one of them.`,
+      severity: 'info',
+    });
+  }
+
+  if (virtualRoots.length > 0) {
+    notes.push({
+      code: 'PROJECT_VIRTUAL_SOURCE',
+      message: `uv.lock records "${virtualRoots[0]}" with source = { virtual = "." }, which uv writes for a project without a [build-system] table. It is intentionally never installed into .venv, and imports still resolve from the working directory.`,
+      severity: 'info',
+    });
+  }
+
   if (conditionalAbsent.length > 0) {
     notes.push({
       code: 'CONDITIONAL_PACKAGES_ABSENT',

package/src/project/inspect.ts

@@ -5,7 +5,8 @@ import {
   type ConformanceReport,
 } from './conformance.ts';
 import type { InstalledEnvironment } from './installed.ts';
-import type { ScanPayload } from './scanner.ts';
+import type { PytestConfiguration } from './pytest-config.ts';
+import type { LockComparison, LockSection, ManifestSection, ScanPayload } from './scanner.ts';
 
 export interface ProjectInspection {
   root: string;
@@ -44,64 +45,67 @@ export interface InspectInput {
   /** `undefined` when no .gitignore exists, so the check stays honest. */
   venvIgnored?: boolean;
   hasTestsDirectory: boolean;
+  /** Test directories found relative to the root; names them in the diagnostic. */
+  testDirectories?: string[];
+  /**
+   * Where pytest configuration was found. The scanner only reads
+   * `pyproject.toml`, so INI files are decided by the caller.
+   */
+  pytestConfiguration?: PytestConfiguration;
   /** Distributions read from `.venv`; omit to skip the conformance comparison. */
   installed?: InstalledEnvironment;
 }
 
-/**
- * Turn a scanner payload into a project model plus diagnostics. Pure so the
- * whole diagnostic surface is unit-testable without touching a filesystem.
- */
-export function inspectProject(input: InspectInput): ProjectInspection {
-  const { payload, venvDir, venvIgnored, hasTestsDirectory, installed } = input;
-  const manifest = payload.manifest;
-  const lock = payload.lock;
-  const comparison = payload.lockComparison;
-  const warnings: Diagnostic[] = [];
-  const notes: Diagnostic[] = [];
-  const suggestions: Suggestion[] = [];
+interface DiagnosticCollector {
+  warnings: Diagnostic[];
+  notes: Diagnostic[];
+  suggestions: Suggestion[];
+}
 
-  const root = payload.root;
+function collectManifestDiagnostics(
+  manifest: ManifestSection | null | undefined,
+  root: string,
+  collector: DiagnosticCollector,
+): void {
   if (manifest?.tomlError) {
-    warnings.push(
+    collector.warnings.push(
       warn('TOML_PARSE_ERROR', manifest.tomlError, manifest.pyprojectPath ?? undefined),
     );
   }
   for (const message of manifest?.warnings ?? []) {
-    warnings.push(warn('MANIFEST_WARNING', message, manifest?.pyprojectPath ?? undefined));
-  }
-  for (const message of lock?.warnings ?? []) {
-    notes.push({ code: 'LOCKFILE_NOTE', message, severity: 'info' });
+    collector.warnings.push(
+      warn('MANIFEST_WARNING', message, manifest?.pyprojectPath ?? undefined),
+    );
   }
 
   if (!manifest?.pyprojectPath) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'PYPROJECT_MISSING',
         'pyproject.toml was not found; dependencies, layout, and tool configuration cannot be verified.',
       ),
     );
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Run uv init to create a pyproject.toml, then uv add the runtime dependencies.',
       confidence: 'high',
       command: 'uv init',
     });
   } else if (!manifest.name) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'PROJECT_NAME_MISSING',
         'pyproject.toml has no [project] name, so the installed distribution name is unknown.',
         manifest.pyprojectPath ?? undefined,
       ),
     );
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Add a [project] table with name and version to pyproject.toml.',
       confidence: 'high',
     });
   }
 
   if (manifest?.legacySetupPy || manifest?.legacySetupCfg) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'LEGACY_PACKAGING',
         `The project still uses ${[
@@ -113,14 +117,14 @@ export function inspectProject(input: InspectInput): ProjectInspection {
         root,
       ),
     );
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Move dependency metadata from setup.py/setup.cfg into [project] in pyproject.toml.',
       confidence: 'medium',
     });
   }
 
   if (manifest?.requirementsFiles.length && manifest.pyprojectPath) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'DUPLICATE_DEPENDENCY_SOURCE',
         `${manifest.requirementsFiles.join(', ')} also declares dependencies; uv resolves from pyproject.toml and uv.lock only.`,
@@ -129,14 +133,31 @@ export function inspectProject(input: InspectInput): ProjectInspection {
     );
   }
 
+  if (manifest?.legacySetupPy && manifest.buildBackend === null && !manifest.pyprojectPath) {
+    collector.suggestions.push({
+      message: 'uv manages dependencies from pyproject.toml; migrate before running uv sync.',
+      confidence: 'medium',
+    });
+  }
+}
+
+function collectLockDiagnostics(
+  lock: LockSection | null | undefined,
+  comparison: LockComparison | null | undefined,
+  collector: DiagnosticCollector,
+): void {
+  for (const message of lock?.warnings ?? []) {
+    collector.notes.push({ code: 'LOCKFILE_NOTE', message, severity: 'info' });
+  }
+
   if (!lock?.present) {
-    notes.push({
+    collector.notes.push({
       code: 'LOCKFILE_MISSING',
       message:
         'uv.lock was not found, so dependency drift and exact resolved versions cannot be verified.',
       severity: 'info',
     });
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Run uv lock to record resolved versions in uv.lock.',
       confidence: 'high',
       command: 'uv lock',
@@ -144,14 +165,14 @@ export function inspectProject(input: InspectInput): ProjectInspection {
   }
 
   if (comparison?.requiresPythonMismatch) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'REQUIRES_PYTHON_MISMATCH',
         `pyproject.toml requires-python is "${comparison.requiresPythonMismatch.manifest}" but uv.lock records "${comparison.requiresPythonMismatch.lock}".`,
         lock?.path ?? undefined,
       ),
     );
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Run uv lock so the lockfile reflects the current requires-python constraint.',
       confidence: 'high',
       command: 'uv lock',
@@ -159,7 +180,7 @@ export function inspectProject(input: InspectInput): ProjectInspection {
   }
 
   for (const name of comparison?.missingFromLock ?? []) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'LOCKFILE_MISSING_DEPENDENCY',
         `"${name}" is declared in pyproject.toml but absent from uv.lock.`,
@@ -168,7 +189,7 @@ export function inspectProject(input: InspectInput): ProjectInspection {
     );
   }
   if (comparison?.missingFromLock.length) {
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Run uv lock to add the missing declarations to the lockfile.',
       confidence: 'high',
       command: 'uv lock',
@@ -176,7 +197,7 @@ export function inspectProject(input: InspectInput): ProjectInspection {
   }
 
   for (const entry of comparison?.unsatisfiedInLock ?? []) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'LOCKFILE_UNSATISFIED_DEPENDENCY',
         `"${entry.name}" is locked at ${entry.locked} which does not satisfy "${entry.specifier}".`,
@@ -186,59 +207,82 @@ export function inspectProject(input: InspectInput): ProjectInspection {
   }
 
   if (lock?.present && comparison && !comparison.specifierCheckAvailable) {
-    notes.push({
+    collector.notes.push({
       code: 'SPECIFIER_CHECK_UNAVAILABLE',
       message:
         'The packaging library was unavailable, so only declared-versus-locked names were compared, not version constraints.',
       severity: 'info',
     });
-    suggestions.push({
+    collector.suggestions.push({
       message:
         'Install the packaging library in the analysing interpreter to compare declared version constraints against uv.lock.',
       confidence: 'medium',
       command: 'python3 -m pip install packaging',
     });
   }
+}
 
+function collectEnvironmentDiagnostics(
+  root: string,
+  manifest: ManifestSection | null | undefined,
+  venvDir: string | undefined,
+  venvIgnored: boolean | undefined,
+  hasTestsDirectory: boolean,
+  testDirectories: string[] | undefined,
+  pytestConfiguration: PytestConfiguration | undefined,
+  collector: DiagnosticCollector,
+): void {
   if (!venvDir) {
-    notes.push({
+    collector.notes.push({
       code: 'VENV_MISSING',
       message: 'No .venv directory exists at the project root; run uv sync before running tests.',
       severity: 'info',
     });
   } else if (venvIgnored === false) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'VENV_NOT_IGNORED',
         '.venv exists but is not listed in .gitignore.',
         `${root}/.gitignore`,
       ),
     );
-    suggestions.push({
+    collector.suggestions.push({
       message: 'Add .venv/ to .gitignore so the environment is never committed.',
       confidence: 'high',
     });
   }
 
   if (!hasTestsDirectory) {
-    notes.push({
+    collector.notes.push({
       code: 'TESTS_DIRECTORY_MISSING',
       message:
-        'No tests/ directory was found; test selection and TDD gates cannot match changed sources.',
+        'No tests directory was found in the project root or inside a top-level package, so test selection and TDD gates cannot match changed sources.',
+      severity: 'info',
+    });
+  } else if (testDirectories && testDirectories.length > 0) {
+    collector.notes.push({
+      code: 'TESTS_DIRECTORY_FOUND',
+      message: `Tests live in ${testDirectories.slice(0, 4).join(', ')}${testDirectories.length > 4 ? `, … (+${testDirectories.length - 4})` : ''}. Confirm testpaths covers them when running pytest without a target.`,
       severity: 'info',
     });
   }
 
-  if (manifest?.pyprojectPath && manifest.toolConfiguration && !manifest.toolConfiguration.pytest) {
-    notes.push({
+  // pytest can be configured from pytest.ini, tox.ini, or setup.cfg, not only
+  // from pyproject.toml; checking one file reported "not configured" for most
+  // projects that use pytest's own configuration file.
+  const pytestConfigured =
+    pytestConfiguration?.configured ?? manifest?.toolConfiguration?.pytest === true;
+  if (manifest?.pyprojectPath && !pytestConfigured) {
+    collector.notes.push({
       code: 'PYTEST_NOT_CONFIGURED',
-      message: 'pyproject.toml has no [tool.pytest.ini_options] table.',
+      message:
+        'No pytest configuration was found in pyproject.toml, pytest.ini, tox.ini, or setup.cfg.',
       severity: 'info',
     });
   }
 
   if (manifest?.layout === 'src' && manifest.modules.length === 0) {
-    warnings.push(
+    collector.warnings.push(
       warn(
         'EMPTY_SRC_LAYOUT',
         'The src/ directory exists but contains no importable module directories or modules.',
@@ -247,20 +291,49 @@ export function inspectProject(input: InspectInput): ProjectInspection {
     );
   }
 
-  if (manifest?.legacySetupPy && manifest.buildBackend === null && !manifest.pyprojectPath) {
-    suggestions.push({
-      message: 'uv manages dependencies from pyproject.toml; migrate before running uv sync.',
-      confidence: 'medium',
-    });
-  }
-
   if (manifest?.uvWorkspaceMembers.length) {
-    notes.push({
+    collector.notes.push({
       code: 'UV_WORKSPACE',
       message: `This is a uv workspace with ${manifest.uvWorkspaceMembers.length} member(s); scope build and test tools per member.`,
       severity: 'info',
     });
   }
+}
+
+/**
+ * Turn a scanner payload into a project model plus diagnostics. Pure so the
+ * whole diagnostic surface is unit-testable without touching a filesystem.
+ */
+export function inspectProject(input: InspectInput): ProjectInspection {
+  const {
+    payload,
+    venvDir,
+    venvIgnored,
+    hasTestsDirectory,
+    testDirectories,
+    pytestConfiguration,
+    installed,
+  } = input;
+  const manifest = payload.manifest;
+  const lock = payload.lock;
+  const comparison = payload.lockComparison;
+  const root = payload.root;
+
+  const collector: DiagnosticCollector = { warnings: [], notes: [], suggestions: [] };
+  collectManifestDiagnostics(manifest, root, collector);
+  collectLockDiagnostics(lock, comparison, collector);
+  collectEnvironmentDiagnostics(
+    root,
+    manifest,
+    venvDir,
+    venvIgnored,
+    hasTestsDirectory,
+    testDirectories,
+    pytestConfiguration,
+    collector,
+  );
+
+  const { warnings, notes, suggestions } = collector;
 
   const conformance =
     installed !== undefined
@@ -277,7 +350,7 @@ export function inspectProject(input: InspectInput): ProjectInspection {
     if (conformance.findings.some((finding) => finding.code === 'PROJECT_NOT_INSTALLED')) {
       suggestions.push({
         message:
-          'The project is not installed in .venv. Run uv sync; if that fails, the build backend could not find the package (check that the module directory name matches [project] name).',
+          'The project is recorded as an editable install but is missing from .venv. Run uv sync; if that fails, the build backend could not find the package (check that the module directory name matches [project] name).',
         confidence: 'high',
         command: 'uv sync',
       });

package/src/project/paths.ts

@@ -21,6 +21,21 @@ export function isTestFile(path: string): boolean {
   return TEST_DIRECTORY.test(posix) || TEST_FILENAME.test(posix);
 }
 
+const RUNNABLE_TEST_FILENAME = /^test_.*\.[a-z]+$/i;
+const RUNNABLE_TEST_SUFFIX = /_test\.[a-z]+$/i;
+
+/**
+ * A file pytest actually collects tests from.
+ *
+ * Living under `tests/` is not enough: `tests/__init__.py`, `tests/conftest.py`,
+ * and `tests/utils.py` are test *infrastructure*, and naming them as pytest
+ * targets overstates what the selection covers.
+ */
+export function isRunnableTestFile(path: string): boolean {
+  const name = basename(toPosix(path));
+  return RUNNABLE_TEST_FILENAME.test(name) || RUNNABLE_TEST_SUFFIX.test(name);
+}
+
 export function isSourceFile(path: string): boolean {
   return isPythonFile(path) && !isTestFile(path);
 }

package/src/project/pytest-config.ts

@@ -0,0 +1,45 @@
+/**
+ * Where pytest configuration can live. `pyproject.toml` is read by the scanner
+ * (tomllib) and passed in already-decided; the INI files have to be inspected
+ * here because only `pytest.ini` is unambiguously a pytest file.
+ */
+export interface PytestConfiguration {
+  configured: boolean;
+  /** Files that define pytest configuration, in the order they were checked. */
+  sources: string[];
+}
+
+export interface PytestConfigurationInput {
+  /** True when pyproject.toml has a `[tool.pytest.ini_options]` table. */
+  pyprojectConfigured: boolean;
+  /**
+   * Raw contents of `pytest.ini`, `tox.ini`, and `setup.cfg`, keyed by file
+   * name. A missing key means the file does not exist.
+   */
+  iniFiles: Record<string, string | undefined>;
+}
+
+/** `[pytest]` (pytest.ini) and `[tool:pytest]` (setup.cfg / tox.ini). */
+const PYTEST_SECTION = /^\s*\[(?:tool:)?pytest\]\s*$/m;
+
+/**
+ * Deciding whether pytest is configured used to look at `pyproject.toml`
+ * alone, which reports "not configured" for every project that keeps
+ * `pytest.ini` — the file pytest itself recommends.
+ *
+ * `pytest.ini` counts on existence because it has no other purpose. `tox.ini`
+ * and `setup.cfg` are shared files, so they only count when they actually carry
+ * a pytest section.
+ */
+export function detectPytestConfiguration(input: PytestConfigurationInput): PytestConfiguration {
+  const sources: string[] = [];
+  if (input.pyprojectConfigured) sources.push('pyproject.toml');
+
+  for (const name of ['pytest.ini', 'tox.ini', 'setup.cfg']) {
+    const content = input.iniFiles[name];
+    if (content === undefined) continue;
+    if (name === 'pytest.ini' || PYTEST_SECTION.test(content)) sources.push(name);
+  }
+
+  return { configured: sources.length > 0, sources };
+}